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/histogram-inl.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 21 | #include "base/macros.h" |
| 22 | #include "base/mutex.h" |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 23 | #include "base/timing_logger.h" |
Nicolas Geoffray | 9ac09ee | 2019-05-08 23:38:27 +0100 | [diff] [blame] | 24 | #include "handle.h" |
Mathieu Chartier | ef41db7 | 2016-10-25 15:08:01 -0700 | [diff] [blame] | 25 | #include "jit/profile_saver_options.h" |
| 26 | #include "obj_ptr.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; |
David Sehr | 9323e6e | 2016-09-13 08:58:35 -0700 | [diff] [blame] | 32 | class ClassLinker; |
Nicolas Geoffray | 9ac09ee | 2019-05-08 23:38:27 +0100 | [diff] [blame] | 33 | class DexFile; |
Nicolas Geoffray | dc2fbb6 | 2019-04-11 22:55:50 +0100 | [diff] [blame] | 34 | class OatDexFile; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 35 | struct RuntimeArgumentMap; |
Vladimir Marko | 3a21e38 | 2016-09-02 12:38:38 +0100 | [diff] [blame] | 36 | union JValue; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 37 | |
David Sehr | 709b070 | 2016-10-13 09:12:37 -0700 | [diff] [blame] | 38 | namespace mirror { |
| 39 | class Object; |
| 40 | class Class; |
Nicolas Geoffray | 9ac09ee | 2019-05-08 23:38:27 +0100 | [diff] [blame] | 41 | class ClassLoader; |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame^] | 42 | class String; |
David Sehr | 709b070 | 2016-10-13 09:12:37 -0700 | [diff] [blame] | 43 | } // namespace mirror |
| 44 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 45 | namespace jit { |
| 46 | |
| 47 | class JitCodeCache; |
Nicolas Geoffray | 7f7539b | 2019-06-06 16:20:54 +0100 | [diff] [blame] | 48 | class JitMemoryRegion; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 49 | class JitOptions; |
| 50 | |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 51 | static constexpr int16_t kJitCheckForOSR = -1; |
| 52 | static constexpr int16_t kJitHotnessDisabled = -2; |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 53 | // At what priority to schedule jit threads. 9 is the lowest foreground priority on device. |
| 54 | // See android/os/Process.java. |
| 55 | static constexpr int kJitPoolThreadPthreadDefaultPriority = 9; |
David Srbecky | e3fc2d1 | 2018-11-30 13:41:14 +0000 | [diff] [blame] | 56 | static constexpr uint32_t kJitSamplesBatchSize = 32; // Must be power of 2. |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 57 | |
| 58 | class JitOptions { |
| 59 | public: |
| 60 | static JitOptions* CreateFromRuntimeArguments(const RuntimeArgumentMap& options); |
| 61 | |
| 62 | uint16_t GetCompileThreshold() const { |
| 63 | return compile_threshold_; |
| 64 | } |
| 65 | |
| 66 | uint16_t GetWarmupThreshold() const { |
| 67 | return warmup_threshold_; |
| 68 | } |
| 69 | |
| 70 | uint16_t GetOsrThreshold() const { |
| 71 | return osr_threshold_; |
| 72 | } |
| 73 | |
| 74 | uint16_t GetPriorityThreadWeight() const { |
| 75 | return priority_thread_weight_; |
| 76 | } |
| 77 | |
| 78 | uint16_t GetInvokeTransitionWeight() const { |
| 79 | return invoke_transition_weight_; |
| 80 | } |
| 81 | |
| 82 | size_t GetCodeCacheInitialCapacity() const { |
| 83 | return code_cache_initial_capacity_; |
| 84 | } |
| 85 | |
| 86 | size_t GetCodeCacheMaxCapacity() const { |
| 87 | return code_cache_max_capacity_; |
| 88 | } |
| 89 | |
| 90 | bool DumpJitInfoOnShutdown() const { |
| 91 | return dump_info_on_shutdown_; |
| 92 | } |
| 93 | |
| 94 | const ProfileSaverOptions& GetProfileSaverOptions() const { |
| 95 | return profile_saver_options_; |
| 96 | } |
| 97 | |
| 98 | bool GetSaveProfilingInfo() const { |
| 99 | return profile_saver_options_.IsEnabled(); |
| 100 | } |
| 101 | |
| 102 | int GetThreadPoolPthreadPriority() const { |
| 103 | return thread_pool_pthread_priority_; |
| 104 | } |
| 105 | |
| 106 | bool UseJitCompilation() const { |
| 107 | return use_jit_compilation_; |
| 108 | } |
| 109 | |
| 110 | void SetUseJitCompilation(bool b) { |
| 111 | use_jit_compilation_ = b; |
| 112 | } |
| 113 | |
| 114 | void SetSaveProfilingInfo(bool save_profiling_info) { |
| 115 | profile_saver_options_.SetEnabled(save_profiling_info); |
| 116 | } |
| 117 | |
| 118 | void SetWaitForJitNotificationsToSaveProfile(bool value) { |
| 119 | profile_saver_options_.SetWaitForJitNotificationsToSave(value); |
| 120 | } |
| 121 | |
| 122 | void SetProfileAOTCode(bool value) { |
| 123 | profile_saver_options_.SetProfileAOTCode(value); |
| 124 | } |
| 125 | |
| 126 | void SetJitAtFirstUse() { |
| 127 | use_jit_compilation_ = true; |
| 128 | compile_threshold_ = 0; |
| 129 | } |
| 130 | |
| 131 | private: |
David Srbecky | e3fc2d1 | 2018-11-30 13:41:14 +0000 | [diff] [blame] | 132 | // We add the sample in batches of size kJitSamplesBatchSize. |
| 133 | // This method rounds the threshold so that it is multiple of the batch size. |
| 134 | static uint32_t RoundUpThreshold(uint32_t threshold); |
| 135 | |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 136 | bool use_jit_compilation_; |
| 137 | size_t code_cache_initial_capacity_; |
| 138 | size_t code_cache_max_capacity_; |
David Srbecky | e3fc2d1 | 2018-11-30 13:41:14 +0000 | [diff] [blame] | 139 | uint32_t compile_threshold_; |
| 140 | uint32_t warmup_threshold_; |
| 141 | uint32_t osr_threshold_; |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 142 | uint16_t priority_thread_weight_; |
| 143 | uint16_t invoke_transition_weight_; |
| 144 | bool dump_info_on_shutdown_; |
| 145 | int thread_pool_pthread_priority_; |
| 146 | ProfileSaverOptions profile_saver_options_; |
| 147 | |
| 148 | JitOptions() |
| 149 | : use_jit_compilation_(false), |
| 150 | code_cache_initial_capacity_(0), |
| 151 | code_cache_max_capacity_(0), |
| 152 | compile_threshold_(0), |
| 153 | warmup_threshold_(0), |
| 154 | osr_threshold_(0), |
| 155 | priority_thread_weight_(0), |
| 156 | invoke_transition_weight_(0), |
| 157 | dump_info_on_shutdown_(false), |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 158 | thread_pool_pthread_priority_(kJitPoolThreadPthreadDefaultPriority) {} |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 159 | |
| 160 | DISALLOW_COPY_AND_ASSIGN(JitOptions); |
| 161 | }; |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 162 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 163 | class Jit { |
| 164 | public: |
Nicolas Geoffray | 71cd50f | 2016-04-14 15:00:33 +0100 | [diff] [blame] | 165 | static constexpr size_t kDefaultPriorityThreadWeightRatio = 1000; |
Nicolas Geoffray | bd553eb | 2016-04-28 13:56:04 +0100 | [diff] [blame] | 166 | static constexpr size_t kDefaultInvokeTransitionWeightRatio = 500; |
buzbee | 42a09cb0 | 2017-02-01 09:08:31 -0800 | [diff] [blame] | 167 | // How frequently should the interpreter check to see if OSR compilation is ready. |
David Srbecky | e3fc2d1 | 2018-11-30 13:41:14 +0000 | [diff] [blame] | 168 | static constexpr int16_t kJitRecheckOSRThreshold = 101; // Prime number to avoid patterns. |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 169 | |
| 170 | virtual ~Jit(); |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 171 | |
| 172 | // Create JIT itself. |
| 173 | static Jit* Create(JitCodeCache* code_cache, JitOptions* options); |
| 174 | |
Nicolas Geoffray | d2f13ba | 2019-06-04 16:48:58 +0100 | [diff] [blame] | 175 | bool CompileMethod(ArtMethod* method, Thread* self, bool baseline, bool osr, bool prejit) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 176 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 177 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 178 | const JitCodeCache* GetCodeCache() const { |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 179 | return code_cache_; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 180 | } |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 181 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 182 | JitCodeCache* GetCodeCache() { |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 183 | return code_cache_; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 184 | } |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 185 | |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 186 | void CreateThreadPool(); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 187 | void DeleteThreadPool(); |
Mathieu Chartier | 93c21ba | 2018-12-10 13:08:30 -0800 | [diff] [blame] | 188 | void WaitForWorkersToBeCreated(); |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 189 | |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 190 | // Dump interesting info: #methods compiled, code vs data size, compile / verify cumulative |
| 191 | // loggers. |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 192 | void DumpInfo(std::ostream& os) REQUIRES(!lock_); |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 193 | // Add a timing logger to cumulative_timings_. |
| 194 | void AddTimingLogger(const TimingLogger& logger); |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 195 | |
| 196 | void AddMemoryUsage(ArtMethod* method, size_t bytes) |
| 197 | REQUIRES(!lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 198 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 199 | |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 200 | uint16_t OSRMethodThreshold() const { |
| 201 | return options_->GetOsrThreshold(); |
Mathieu Chartier | a50f9cf | 2015-09-25 11:34:45 -0700 | [diff] [blame] | 202 | } |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 203 | |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 204 | uint16_t HotMethodThreshold() const { |
| 205 | return options_->GetCompileThreshold(); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 206 | } |
| 207 | |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 208 | uint16_t WarmMethodThreshold() const { |
| 209 | return options_->GetWarmupThreshold(); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | uint16_t PriorityThreadWeight() const { |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 213 | return options_->GetPriorityThreadWeight(); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 214 | } |
| 215 | |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame^] | 216 | // Return whether we should do JIT compilation. Note this will returns false |
| 217 | // if we only need to save profile information and not compile methods. |
Nicolas Geoffray | 2fef66b | 2019-06-26 22:00:02 +0000 | [diff] [blame] | 218 | bool UseJitCompilation() const { |
| 219 | return options_->UseJitCompilation(); |
| 220 | } |
Calin Juravle | ffc8707 | 2016-04-20 14:22:09 +0100 | [diff] [blame] | 221 | |
Calin Juravle | 138dbff | 2016-06-28 19:36:58 +0100 | [diff] [blame] | 222 | bool GetSaveProfilingInfo() const { |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 223 | return options_->GetSaveProfilingInfo(); |
Calin Juravle | ffc8707 | 2016-04-20 14:22:09 +0100 | [diff] [blame] | 224 | } |
| 225 | |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 226 | // Wait until there is no more pending compilation tasks. |
| 227 | void WaitForCompilationToFinish(Thread* self); |
| 228 | |
| 229 | // Profiling methods. |
| 230 | void MethodEntered(Thread* thread, ArtMethod* method) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 231 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 232 | |
David Srbecky | e3fc2d1 | 2018-11-30 13:41:14 +0000 | [diff] [blame] | 233 | ALWAYS_INLINE void AddSamples(Thread* self, |
| 234 | ArtMethod* method, |
| 235 | uint16_t samples, |
| 236 | bool with_backedges) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 237 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 238 | |
Mathieu Chartier | ef41db7 | 2016-10-25 15:08:01 -0700 | [diff] [blame] | 239 | void InvokeVirtualOrInterface(ObjPtr<mirror::Object> this_object, |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 240 | ArtMethod* caller, |
| 241 | uint32_t dex_pc, |
| 242 | ArtMethod* callee) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 243 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 274fe4a | 2016-04-12 16:33:24 +0100 | [diff] [blame] | 244 | |
Nicolas Geoffray | 71cd50f | 2016-04-14 15:00:33 +0100 | [diff] [blame] | 245 | void NotifyInterpreterToCompiledCodeTransition(Thread* self, ArtMethod* caller) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 246 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 247 | AddSamples(self, caller, options_->GetInvokeTransitionWeight(), false); |
Nicolas Geoffray | 71cd50f | 2016-04-14 15:00:33 +0100 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | void NotifyCompiledCodeToInterpreterTransition(Thread* self, ArtMethod* callee) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 251 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 252 | AddSamples(self, callee, options_->GetInvokeTransitionWeight(), false); |
Nicolas Geoffray | 71cd50f | 2016-04-14 15:00:33 +0100 | [diff] [blame] | 253 | } |
| 254 | |
Calin Juravle | c90bc92 | 2016-02-24 10:13:09 +0000 | [diff] [blame] | 255 | // Starts the profile saver if the config options allow profile recording. |
| 256 | // The profile will be stored in the specified `filename` and will contain |
| 257 | // information collected from the given `code_paths` (a set of dex locations). |
Calin Juravle | c90bc92 | 2016-02-24 10:13:09 +0000 | [diff] [blame] | 258 | void StartProfileSaver(const std::string& filename, |
Calin Juravle | 77651c4 | 2017-03-03 18:04:02 -0800 | [diff] [blame] | 259 | const std::vector<std::string>& code_paths); |
Calin Juravle | 4d77b6a | 2015-12-01 18:38:09 +0000 | [diff] [blame] | 260 | void StopProfileSaver(); |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 261 | |
Calin Juravle | b8e6999 | 2016-03-09 15:37:48 +0000 | [diff] [blame] | 262 | void DumpForSigQuit(std::ostream& os) REQUIRES(!lock_); |
Nicolas Geoffray | aee2156 | 2015-12-15 16:39:44 +0000 | [diff] [blame] | 263 | |
Tamas Berghammer | 160e6df | 2016-01-05 14:29:02 +0000 | [diff] [blame] | 264 | static void NewTypeLoadedIfUsingJit(mirror::Class* type) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 265 | REQUIRES_SHARED(Locks::mutator_lock_); |
Tamas Berghammer | 160e6df | 2016-01-05 14:29:02 +0000 | [diff] [blame] | 266 | |
Tamas Berghammer | fffbee4 | 2016-01-15 13:09:34 +0000 | [diff] [blame] | 267 | // If debug info generation is turned on then write the type information for types already loaded |
| 268 | // into the specified class linker to the jit debug interface, |
| 269 | void DumpTypeInfoForLoadedTypes(ClassLinker* linker); |
| 270 | |
Nicolas Geoffray | 3512244 | 2016-03-02 12:05:30 +0000 | [diff] [blame] | 271 | // 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] | 272 | bool JitAtFirstUse(); |
| 273 | |
Nicolas Geoffray | 3512244 | 2016-03-02 12:05:30 +0000 | [diff] [blame] | 274 | // Return whether we can invoke JIT code for `method`. |
| 275 | bool CanInvokeCompiledCode(ArtMethod* method); |
| 276 | |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 277 | // Return whether the runtime should use a priority thread weight when sampling. |
Vladimir Marko | a710d91 | 2017-09-12 14:56:07 +0100 | [diff] [blame] | 278 | static bool ShouldUsePriorityThreadWeight(Thread* self); |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 279 | |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 280 | // If an OSR compiled version is available for `method`, |
| 281 | // and `dex_pc + dex_pc_offset` is an entry point of that compiled |
| 282 | // version, this method will jump to the compiled code, let it run, |
| 283 | // and return true afterwards. Return false otherwise. |
| 284 | static bool MaybeDoOnStackReplacement(Thread* thread, |
| 285 | ArtMethod* method, |
| 286 | uint32_t dex_pc, |
| 287 | int32_t dex_pc_offset, |
| 288 | JValue* result) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 289 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 290 | |
Nicolas Geoffray | a7edd0d | 2018-11-07 03:18:16 +0000 | [diff] [blame] | 291 | // Load the compiler library. |
| 292 | static bool LoadCompilerLibrary(std::string* error_msg); |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 293 | |
Andreas Gampe | f149b3f | 2016-11-16 14:58:24 -0800 | [diff] [blame] | 294 | ThreadPool* GetThreadPool() const { |
| 295 | return thread_pool_.get(); |
| 296 | } |
| 297 | |
Nicolas Geoffray | 021c5f2 | 2016-12-16 11:22:05 +0000 | [diff] [blame] | 298 | // Stop the JIT by waiting for all current compilations and enqueued compilations to finish. |
| 299 | void Stop(); |
| 300 | |
| 301 | // Start JIT threads. |
| 302 | void Start(); |
| 303 | |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 304 | // Transition to a child state. |
Nicolas Geoffray | 0d54cfb | 2019-05-03 09:13:52 +0100 | [diff] [blame] | 305 | void PostForkChildAction(bool is_system_server, bool is_zygote); |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 306 | |
| 307 | // Prepare for forking. |
| 308 | void PreZygoteFork(); |
| 309 | |
| 310 | // Adjust state after forking. |
| 311 | void PostZygoteFork(); |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 312 | |
Nicolas Geoffray | 9ac09ee | 2019-05-08 23:38:27 +0100 | [diff] [blame] | 313 | // Compile methods from the given profile. If `add_to_queue` is true, methods |
| 314 | // in the profile are added to the JIT queue. Otherwise they are compiled |
| 315 | // directly. |
| 316 | void CompileMethodsFromProfile(Thread* self, |
| 317 | const std::vector<const DexFile*>& dex_files, |
| 318 | const std::string& profile_path, |
| 319 | Handle<mirror::ClassLoader> class_loader, |
| 320 | bool add_to_queue); |
| 321 | |
| 322 | // Register the dex files to the JIT. This is to perform any compilation/optimization |
| 323 | // at the point of loading the dex files. |
| 324 | void RegisterDexFiles(const std::vector<std::unique_ptr<const DexFile>>& dex_files, |
Nicolas Geoffray | 741a070 | 2019-06-10 11:18:11 +0100 | [diff] [blame] | 325 | jobject class_loader); |
Nicolas Geoffray | de1b2a2 | 2019-02-27 09:10:57 +0000 | [diff] [blame] | 326 | |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame^] | 327 | // Called by the compiler to know whether it can directly encode the |
| 328 | // method/class/string. |
| 329 | bool CanEncodeMethod(ArtMethod* method, bool is_for_shared_region) const; |
| 330 | bool CanEncodeClass(ObjPtr<mirror::Class> cls, bool is_for_shared_region) const |
| 331 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 332 | bool CanEncodeString(ObjPtr<mirror::String> string, bool is_for_shared_region) const |
| 333 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 334 | bool CanAssumeInitialized(ObjPtr<mirror::Class> cls, bool is_for_shared_region) const |
| 335 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 336 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 337 | private: |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 338 | Jit(JitCodeCache* code_cache, JitOptions* options); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 339 | |
David Srbecky | e3fc2d1 | 2018-11-30 13:41:14 +0000 | [diff] [blame] | 340 | // Compile the method if the number of samples passes a threshold. |
| 341 | // Returns false if we can not compile now - don't increment the counter and retry later. |
| 342 | bool MaybeCompileMethod(Thread* self, |
| 343 | ArtMethod* method, |
| 344 | uint32_t old_count, |
| 345 | uint32_t new_count, |
| 346 | bool with_backedges) |
| 347 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 348 | |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 349 | static bool BindCompilerMethods(std::string* error_msg); |
Mathieu Chartier | c1bc415 | 2016-03-24 17:22:52 -0700 | [diff] [blame] | 350 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 351 | // JIT compiler |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 352 | static void* jit_library_handle_; |
| 353 | static void* jit_compiler_handle_; |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 354 | static void* (*jit_load_)(void); |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 355 | static void (*jit_unload_)(void*); |
Nicolas Geoffray | 7f7539b | 2019-06-06 16:20:54 +0100 | [diff] [blame] | 356 | static bool (*jit_compile_method_)(void*, JitMemoryRegion*, ArtMethod*, Thread*, bool, bool); |
Mathieu Chartier | 72918ea | 2016-03-24 11:07:06 -0700 | [diff] [blame] | 357 | static void (*jit_types_loaded_)(void*, mirror::Class**, size_t count); |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 358 | static void (*jit_update_options_)(void*); |
| 359 | static bool (*jit_generate_debug_info_)(void*); |
| 360 | template <typename T> static bool LoadSymbol(T*, const char* symbol, std::string* error_msg); |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 361 | |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 362 | // JIT resources owned by runtime. |
| 363 | jit::JitCodeCache* const code_cache_; |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 364 | const JitOptions* const options_; |
| 365 | |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 366 | std::unique_ptr<ThreadPool> thread_pool_; |
Nicolas Geoffray | dc2fbb6 | 2019-04-11 22:55:50 +0100 | [diff] [blame] | 367 | std::vector<std::unique_ptr<OatDexFile>> type_lookup_tables_; |
Nicolas Geoffray | 47b9580 | 2018-05-16 15:42:17 +0100 | [diff] [blame] | 368 | |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 369 | // Performance monitoring. |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 370 | CumulativeLogger cumulative_timings_; |
Nicolas Geoffray | a4f8154 | 2016-03-08 16:57:48 +0000 | [diff] [blame] | 371 | Histogram<uint64_t> memory_use_ GUARDED_BY(lock_); |
| 372 | Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 373 | |
Mathieu Chartier | 3130cdf | 2015-05-03 15:20:23 -0700 | [diff] [blame] | 374 | DISALLOW_COPY_AND_ASSIGN(Jit); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 375 | }; |
| 376 | |
Andreas Gampe | f149b3f | 2016-11-16 14:58:24 -0800 | [diff] [blame] | 377 | // Helper class to stop the JIT for a given scope. This will wait for the JIT to quiesce. |
| 378 | class ScopedJitSuspend { |
| 379 | public: |
| 380 | ScopedJitSuspend(); |
| 381 | ~ScopedJitSuspend(); |
| 382 | |
| 383 | private: |
| 384 | bool was_on_; |
| 385 | }; |
| 386 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 387 | } // namespace jit |
| 388 | } // namespace art |
| 389 | |
| 390 | #endif // ART_RUNTIME_JIT_JIT_H_ |