Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 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_JIT_H_ |
| 18 | #define ART_RUNTIME_JIT_JIT_H_ |
| 19 | |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 20 | #include "base/arena_allocator.h" |
| 21 | #include "base/histogram-inl.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 22 | #include "base/macros.h" |
| 23 | #include "base/mutex.h" |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 24 | #include "base/timing_logger.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 25 | #include "object_callbacks.h" |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 26 | #include "offline_profiling_info.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 27 | #include "thread_pool.h" |
| 28 | |
| 29 | namespace art { |
| 30 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 31 | class ArtMethod; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 32 | struct RuntimeArgumentMap; |
| 33 | |
| 34 | namespace jit { |
| 35 | |
| 36 | class JitCodeCache; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 37 | class JitOptions; |
| 38 | |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 39 | static constexpr int16_t kJitCheckForOSR = -1; |
| 40 | static constexpr int16_t kJitHotnessDisabled = -2; |
| 41 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 42 | class Jit { |
| 43 | public: |
| 44 | static constexpr bool kStressMode = kIsDebugBuild; |
Nicolas Geoffray | 83f080a | 2016-03-08 16:50:21 +0000 | [diff] [blame] | 45 | static constexpr size_t kDefaultCompileThreshold = kStressMode ? 2 : 10000; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 46 | |
| 47 | virtual ~Jit(); |
| 48 | static Jit* Create(JitOptions* options, std::string* error_msg); |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 49 | bool CompileMethod(ArtMethod* method, Thread* self, bool osr) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 50 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 51 | void CreateThreadPool(); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 52 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 53 | const JitCodeCache* GetCodeCache() const { |
| 54 | return code_cache_.get(); |
| 55 | } |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 56 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 57 | JitCodeCache* GetCodeCache() { |
| 58 | return code_cache_.get(); |
| 59 | } |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 60 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 61 | void DeleteThreadPool(); |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 62 | // Dump interesting info: #methods compiled, code vs data size, compile / verify cumulative |
| 63 | // loggers. |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 64 | void DumpInfo(std::ostream& os) REQUIRES(!lock_); |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 65 | // Add a timing logger to cumulative_timings_. |
| 66 | void AddTimingLogger(const TimingLogger& logger); |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 67 | |
| 68 | void AddMemoryUsage(ArtMethod* method, size_t bytes) |
| 69 | REQUIRES(!lock_) |
| 70 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 71 | |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 72 | size_t OSRMethodThreshold() const { |
| 73 | return osr_method_threshold_; |
Mathieu Chartier | a50f9cf | 2015-09-25 11:34:45 -0700 | [diff] [blame] | 74 | } |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 75 | |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 76 | size_t HotMethodThreshold() const { |
| 77 | return hot_method_threshold_; |
| 78 | } |
| 79 | |
| 80 | size_t WarmMethodThreshold() const { |
| 81 | return warm_method_threshold_; |
| 82 | } |
| 83 | |
| 84 | uint16_t PriorityThreadWeight() const { |
| 85 | return priority_thread_weight_; |
| 86 | } |
| 87 | |
| 88 | // Wait until there is no more pending compilation tasks. |
| 89 | void WaitForCompilationToFinish(Thread* self); |
| 90 | |
| 91 | // Profiling methods. |
| 92 | void MethodEntered(Thread* thread, ArtMethod* method) |
| 93 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 94 | |
| 95 | void AddSamples(Thread* self, ArtMethod* method, uint16_t samples) |
| 96 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 97 | |
| 98 | void InvokeVirtualOrInterface(Thread* thread, |
| 99 | mirror::Object* this_object, |
| 100 | ArtMethod* caller, |
| 101 | uint32_t dex_pc, |
| 102 | ArtMethod* callee) |
| 103 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 104 | |
Calin Juravle | c90bc92 | 2016-02-24 10:13:09 +0000 | [diff] [blame] | 105 | // Starts the profile saver if the config options allow profile recording. |
| 106 | // The profile will be stored in the specified `filename` and will contain |
| 107 | // information collected from the given `code_paths` (a set of dex locations). |
| 108 | // The `foreign_dex_profile_path` is the path where the saver will put the |
| 109 | // profile markers for loaded dex files which are not owned by the application. |
| 110 | // The `app_dir` is the application directory and is used to decide which |
| 111 | // dex files belong to the application. |
| 112 | void StartProfileSaver(const std::string& filename, |
| 113 | const std::vector<std::string>& code_paths, |
| 114 | const std::string& foreign_dex_profile_path, |
| 115 | const std::string& app_dir); |
Calin Juravle | 4d77b6a | 2015-12-01 18:38:09 +0000 | [diff] [blame] | 116 | void StopProfileSaver(); |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 117 | |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 118 | void DumpForSigQuit(std::ostream& os) REQUIRES(!lock_) { |
Nicolas Geoffray | aee2156 | 2015-12-15 16:39:44 +0000 | [diff] [blame] | 119 | DumpInfo(os); |
| 120 | } |
| 121 | |
Tamas Berghammer | 160e6df | 2016-01-05 14:29:02 +0000 | [diff] [blame] | 122 | static void NewTypeLoadedIfUsingJit(mirror::Class* type) |
| 123 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 124 | |
Tamas Berghammer | fffbee4 | 2016-01-15 13:09:34 +0000 | [diff] [blame] | 125 | // If debug info generation is turned on then write the type information for types already loaded |
| 126 | // into the specified class linker to the jit debug interface, |
| 127 | void DumpTypeInfoForLoadedTypes(ClassLinker* linker); |
| 128 | |
Nicolas Geoffray | 3512244 | 2016-03-02 12:05:30 +0000 | [diff] [blame] | 129 | // Return whether we should try to JIT compiled code as soon as an ArtMethod is invoked. |
Siva Chandra | 05d2415 | 2016-01-05 17:43:17 -0800 | [diff] [blame] | 130 | bool JitAtFirstUse(); |
| 131 | |
Nicolas Geoffray | 3512244 | 2016-03-02 12:05:30 +0000 | [diff] [blame] | 132 | // Return whether we can invoke JIT code for `method`. |
| 133 | bool CanInvokeCompiledCode(ArtMethod* method); |
| 134 | |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 135 | // Return whether the runtime should use a priority thread weight when sampling. |
| 136 | static bool ShouldUsePriorityThreadWeight(); |
| 137 | |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 138 | // If an OSR compiled version is available for `method`, |
| 139 | // and `dex_pc + dex_pc_offset` is an entry point of that compiled |
| 140 | // version, this method will jump to the compiled code, let it run, |
| 141 | // and return true afterwards. Return false otherwise. |
| 142 | static bool MaybeDoOnStackReplacement(Thread* thread, |
| 143 | ArtMethod* method, |
| 144 | uint32_t dex_pc, |
| 145 | int32_t dex_pc_offset, |
| 146 | JValue* result) |
| 147 | SHARED_REQUIRES(Locks::mutator_lock_); |
| 148 | |
Mathieu Chartier | c1bc415 | 2016-03-24 17:22:52 -0700 | [diff] [blame] | 149 | static bool LoadCompilerLibrary(std::string* error_msg); |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 150 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 151 | private: |
| 152 | Jit(); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 153 | |
Mathieu Chartier | c1bc415 | 2016-03-24 17:22:52 -0700 | [diff] [blame] | 154 | static bool LoadCompiler(std::string* error_msg); |
| 155 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 156 | // JIT compiler |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 157 | static void* jit_library_handle_; |
| 158 | static void* jit_compiler_handle_; |
| 159 | static void* (*jit_load_)(bool*); |
| 160 | static void (*jit_unload_)(void*); |
| 161 | static bool (*jit_compile_method_)(void*, ArtMethod*, Thread*, bool); |
| 162 | static void (*jit_types_loaded_)(void*, mirror::Class**, size_t count); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 163 | |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 164 | // Performance monitoring. |
| 165 | bool dump_info_on_shutdown_; |
| 166 | CumulativeLogger cumulative_timings_; |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 167 | Histogram<uint64_t> memory_use_ GUARDED_BY(lock_); |
| 168 | Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 169 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 170 | std::unique_ptr<jit::JitCodeCache> code_cache_; |
Mathieu Chartier | 3130cdf | 2015-05-03 15:20:23 -0700 | [diff] [blame] | 171 | |
Calin Juravle | 4d77b6a | 2015-12-01 18:38:09 +0000 | [diff] [blame] | 172 | bool save_profiling_info_; |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 173 | static bool generate_debug_info_; |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame^] | 174 | uint16_t hot_method_threshold_; |
| 175 | uint16_t warm_method_threshold_; |
| 176 | uint16_t osr_method_threshold_; |
| 177 | uint16_t priority_thread_weight_; |
| 178 | std::unique_ptr<ThreadPool> thread_pool_; |
Calin Juravle | 4d77b6a | 2015-12-01 18:38:09 +0000 | [diff] [blame] | 179 | |
Mathieu Chartier | 3130cdf | 2015-05-03 15:20:23 -0700 | [diff] [blame] | 180 | DISALLOW_COPY_AND_ASSIGN(Jit); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 181 | }; |
| 182 | |
| 183 | class JitOptions { |
| 184 | public: |
| 185 | static JitOptions* CreateFromRuntimeArguments(const RuntimeArgumentMap& options); |
| 186 | size_t GetCompileThreshold() const { |
| 187 | return compile_threshold_; |
| 188 | } |
Nicolas Geoffray | 5550ca8 | 2015-08-21 18:38:30 +0100 | [diff] [blame] | 189 | size_t GetWarmupThreshold() const { |
| 190 | return warmup_threshold_; |
| 191 | } |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 192 | size_t GetOsrThreshold() const { |
| 193 | return osr_threshold_; |
| 194 | } |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 195 | uint16_t GetPriorityThreadWeight() const { |
| 196 | return priority_thread_weight_; |
| 197 | } |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 198 | size_t GetCodeCacheInitialCapacity() const { |
| 199 | return code_cache_initial_capacity_; |
| 200 | } |
| 201 | size_t GetCodeCacheMaxCapacity() const { |
| 202 | return code_cache_max_capacity_; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 203 | } |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 204 | bool DumpJitInfoOnShutdown() const { |
| 205 | return dump_info_on_shutdown_; |
| 206 | } |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 207 | bool GetSaveProfilingInfo() const { |
| 208 | return save_profiling_info_; |
| 209 | } |
Mathieu Chartier | 455f67c | 2015-03-17 13:48:29 -0700 | [diff] [blame] | 210 | bool UseJIT() const { |
| 211 | return use_jit_; |
| 212 | } |
| 213 | void SetUseJIT(bool b) { |
| 214 | use_jit_ = b; |
| 215 | } |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 216 | void SetSaveProfilingInfo(bool b) { |
| 217 | save_profiling_info_ = b; |
| 218 | } |
Siva Chandra | 05d2415 | 2016-01-05 17:43:17 -0800 | [diff] [blame] | 219 | void SetJitAtFirstUse() { |
| 220 | use_jit_ = true; |
| 221 | compile_threshold_ = 0; |
| 222 | } |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 223 | |
| 224 | private: |
Mathieu Chartier | 455f67c | 2015-03-17 13:48:29 -0700 | [diff] [blame] | 225 | bool use_jit_; |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 226 | size_t code_cache_initial_capacity_; |
| 227 | size_t code_cache_max_capacity_; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 228 | size_t compile_threshold_; |
Nicolas Geoffray | 5550ca8 | 2015-08-21 18:38:30 +0100 | [diff] [blame] | 229 | size_t warmup_threshold_; |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 230 | size_t osr_threshold_; |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 231 | uint16_t priority_thread_weight_; |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 232 | bool dump_info_on_shutdown_; |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 233 | bool save_profiling_info_; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 234 | |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 235 | JitOptions() |
| 236 | : use_jit_(false), |
| 237 | code_cache_initial_capacity_(0), |
| 238 | code_cache_max_capacity_(0), |
| 239 | compile_threshold_(0), |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 240 | dump_info_on_shutdown_(false), |
| 241 | save_profiling_info_(false) { } |
Mathieu Chartier | 3130cdf | 2015-05-03 15:20:23 -0700 | [diff] [blame] | 242 | |
| 243 | DISALLOW_COPY_AND_ASSIGN(JitOptions); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 244 | }; |
| 245 | |
| 246 | } // namespace jit |
| 247 | } // namespace art |
| 248 | |
| 249 | #endif // ART_RUNTIME_JIT_JIT_H_ |