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_CODE_CACHE_H_ |
| 18 | #define ART_RUNTIME_JIT_JIT_CODE_CACHE_H_ |
| 19 | |
Andreas Gampe | f0f3c59 | 2018-06-26 13:28:00 -0700 | [diff] [blame] | 20 | #include <iosfwd> |
| 21 | #include <memory> |
| 22 | #include <set> |
| 23 | #include <string> |
| 24 | #include <unordered_set> |
| 25 | #include <vector> |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 26 | |
Mingyao Yang | 063fc77 | 2016-08-02 11:02:54 -0700 | [diff] [blame] | 27 | #include "base/arena_containers.h" |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 28 | #include "base/array_ref.h" |
David Sehr | c431b9d | 2018-03-02 12:01:51 -0800 | [diff] [blame] | 29 | #include "base/atomic.h" |
Andreas Gampe | f0f3c59 | 2018-06-26 13:28:00 -0700 | [diff] [blame] | 30 | #include "base/histogram.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 31 | #include "base/macros.h" |
Vladimir Marko | c34bebf | 2018-08-16 16:12:49 +0100 | [diff] [blame] | 32 | #include "base/mem_map.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 33 | #include "base/mutex.h" |
David Sehr | 67bf42e | 2018-02-26 16:43:04 -0800 | [diff] [blame] | 34 | #include "base/safe_map.h" |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 35 | #include "jit_memory_region.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 36 | |
| 37 | namespace art { |
| 38 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 39 | class ArtMethod; |
Vladimir Marko | b0b68cf | 2017-11-14 18:11:50 +0000 | [diff] [blame] | 40 | template<class T> class Handle; |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 41 | class LinearAlloc; |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 42 | class InlineCache; |
Andreas Gampe | 5d08fcc | 2017-06-05 17:56:46 -0700 | [diff] [blame] | 43 | class IsMarkedVisitor; |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 44 | class JitJniStubTestHelper; |
Andreas Gampe | 513061a | 2017-06-01 09:17:34 -0700 | [diff] [blame] | 45 | class OatQuickMethodHeader; |
Vladimir Marko | b0b68cf | 2017-11-14 18:11:50 +0000 | [diff] [blame] | 46 | struct ProfileMethodInfo; |
Nicolas Geoffray | 26705e2 | 2015-10-28 12:50:11 +0000 | [diff] [blame] | 47 | class ProfilingInfo; |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 48 | class Thread; |
| 49 | |
| 50 | namespace gc { |
| 51 | namespace accounting { |
| 52 | template<size_t kAlignment> class MemoryRangeBitmap; |
| 53 | } // namespace accounting |
| 54 | } // namespace gc |
| 55 | |
| 56 | namespace mirror { |
| 57 | class Class; |
| 58 | class Object; |
| 59 | template<class T> class ObjectArray; |
| 60 | } // namespace mirror |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 61 | |
Vladimir Marko | b0b68cf | 2017-11-14 18:11:50 +0000 | [diff] [blame] | 62 | namespace gc { |
| 63 | namespace accounting { |
| 64 | template<size_t kAlignment> class MemoryRangeBitmap; |
| 65 | } // namespace accounting |
| 66 | } // namespace gc |
| 67 | |
| 68 | namespace mirror { |
| 69 | class Class; |
| 70 | class Object; |
| 71 | template<class T> class ObjectArray; |
| 72 | } // namespace mirror |
| 73 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 74 | namespace jit { |
| 75 | |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 76 | class MarkCodeClosure; |
Orion Hodson | df1ab20 | 2019-06-02 16:45:03 +0100 | [diff] [blame] | 77 | |
Orion Hodson | 521ff98 | 2019-06-18 13:56:28 +0100 | [diff] [blame] | 78 | // Type of bitmap used for tracking live functions in the JIT code cache for the purposes |
| 79 | // of garbage collecting code. |
| 80 | using CodeCacheBitmap = gc::accounting::MemoryRangeBitmap<kJitCodeAccountingBytes>; |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 81 | |
Nicolas Geoffray | e3884e3 | 2019-10-28 17:04:49 +0000 | [diff] [blame] | 82 | // The state of profile-based compilation in the zygote. |
| 83 | // - kInProgress: JIT compilation is happening |
| 84 | // - kDone: JIT compilation is finished, and the zygote is preparing notifying |
| 85 | // the other processes. |
| 86 | // - kNotifiedOk: the zygote has notified the other processes, which can start |
| 87 | // sharing the boot image method mappings. |
| 88 | // - kNotifiedFailure: the zygote has notified the other processes, but they |
| 89 | // cannot share the boot image method mappings due to |
| 90 | // unexpected errors |
| 91 | enum class ZygoteCompilationState : uint8_t { |
| 92 | kInProgress = 0, |
| 93 | kDone = 1, |
| 94 | kNotifiedOk = 2, |
| 95 | kNotifiedFailure = 3, |
| 96 | }; |
| 97 | |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 98 | // Class abstraction over a map of ArtMethod -> compiled code, where the |
| 99 | // ArtMethod are compiled by the zygote, and the map acts as a communication |
| 100 | // channel between the zygote and the other processes. |
| 101 | // For the zygote process, this map is the only map it is placing the compiled |
| 102 | // code. JitCodeCache.method_code_map_ is empty. |
| 103 | // |
| 104 | // This map is writable only by the zygote, and readable by all children. |
| 105 | class ZygoteMap { |
| 106 | public: |
Nicolas Geoffray | e3884e3 | 2019-10-28 17:04:49 +0000 | [diff] [blame] | 107 | explicit ZygoteMap(JitMemoryRegion* region) |
| 108 | : map_(), region_(region), compilation_state_(nullptr) {} |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 109 | |
| 110 | // Initialize the data structure so it can hold `number_of_methods` mappings. |
| 111 | // Note that the map is fixed size and never grows. |
| 112 | void Initialize(uint32_t number_of_methods) REQUIRES(!Locks::jit_lock_); |
| 113 | |
| 114 | // Add the mapping method -> code. |
| 115 | void Put(const void* code, ArtMethod* method) REQUIRES(Locks::jit_lock_); |
| 116 | |
| 117 | // Return the code pointer for the given method. If pc is not zero, check that |
| 118 | // the pc falls into that code range. Return null otherwise. |
| 119 | const void* GetCodeFor(ArtMethod* method, uintptr_t pc = 0) const; |
| 120 | |
| 121 | // Return whether the map has associated code for the given method. |
| 122 | bool ContainsMethod(ArtMethod* method) const { |
| 123 | return GetCodeFor(method) != nullptr; |
| 124 | } |
| 125 | |
Nicolas Geoffray | e3884e3 | 2019-10-28 17:04:49 +0000 | [diff] [blame] | 126 | void SetCompilationState(ZygoteCompilationState state) { |
| 127 | region_->WriteData(compilation_state_, state); |
Nicolas Geoffray | 623d4f1 | 2019-09-30 13:45:51 +0100 | [diff] [blame] | 128 | } |
| 129 | |
Nicolas Geoffray | 8852e53 | 2019-10-30 09:43:35 +0000 | [diff] [blame] | 130 | bool IsCompilationDoneButNotNotified() const { |
| 131 | return compilation_state_ != nullptr && *compilation_state_ == ZygoteCompilationState::kDone; |
| 132 | } |
| 133 | |
Nicolas Geoffray | e3884e3 | 2019-10-28 17:04:49 +0000 | [diff] [blame] | 134 | bool IsCompilationNotified() const { |
Nicolas Geoffray | 8852e53 | 2019-10-30 09:43:35 +0000 | [diff] [blame] | 135 | return compilation_state_ != nullptr && *compilation_state_ > ZygoteCompilationState::kDone; |
Nicolas Geoffray | e3884e3 | 2019-10-28 17:04:49 +0000 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | bool CanMapBootImageMethods() const { |
Nicolas Geoffray | 8852e53 | 2019-10-30 09:43:35 +0000 | [diff] [blame] | 139 | return compilation_state_ != nullptr && |
| 140 | *compilation_state_ == ZygoteCompilationState::kNotifiedOk; |
Nicolas Geoffray | 623d4f1 | 2019-09-30 13:45:51 +0100 | [diff] [blame] | 141 | } |
| 142 | |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 143 | private: |
| 144 | struct Entry { |
| 145 | ArtMethod* method; |
| 146 | // Note we currently only allocate code in the low 4g, so we could just reserve 4 bytes |
| 147 | // for the code pointer. For simplicity and in the case we move to 64bit |
| 148 | // addresses for code, just keep it void* for now. |
| 149 | const void* code_ptr; |
| 150 | }; |
| 151 | |
| 152 | // The map allocated with `region_`. |
David Srbecky | 87fb032 | 2019-08-20 10:34:02 +0100 | [diff] [blame] | 153 | ArrayRef<const Entry> map_; |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 154 | |
| 155 | // The region in which the map is allocated. |
| 156 | JitMemoryRegion* const region_; |
| 157 | |
Nicolas Geoffray | e3884e3 | 2019-10-28 17:04:49 +0000 | [diff] [blame] | 158 | // The current state of compilation in the zygote. Starts with kInProgress, |
| 159 | // and should end with kNotifiedOk or kNotifiedFailure. |
| 160 | const ZygoteCompilationState* compilation_state_; |
Nicolas Geoffray | 623d4f1 | 2019-09-30 13:45:51 +0100 | [diff] [blame] | 161 | |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 162 | DISALLOW_COPY_AND_ASSIGN(ZygoteMap); |
| 163 | }; |
| 164 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 165 | class JitCodeCache { |
| 166 | public: |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 167 | static constexpr size_t kMaxCapacity = 64 * MB; |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 168 | // Put the default to a very low amount for debug builds to stress the code cache |
| 169 | // collection. |
Nicolas Geoffray | 7ca4b77 | 2016-02-23 13:52:01 +0000 | [diff] [blame] | 170 | static constexpr size_t kInitialCapacity = kIsDebugBuild ? 8 * KB : 64 * KB; |
Nicolas Geoffray | 65b83d8 | 2016-02-22 13:14:04 +0000 | [diff] [blame] | 171 | |
| 172 | // By default, do not GC until reaching 256KB. |
| 173 | static constexpr size_t kReservedCapacity = kInitialCapacity * 4; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 174 | |
Mathieu Chartier | bce416f | 2015-03-23 12:37:35 -0700 | [diff] [blame] | 175 | // Create the code cache with a code + data capacity equal to "capacity", error message is passed |
| 176 | // in the out arg error_msg. |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 177 | static JitCodeCache* Create(bool used_only_for_profile_data, |
Orion Hodson | ad28f5e | 2018-10-17 09:08:17 +0100 | [diff] [blame] | 178 | bool rwx_memory_allowed, |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 179 | bool is_zygote, |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 180 | std::string* error_msg); |
Vladimir Marko | b0b68cf | 2017-11-14 18:11:50 +0000 | [diff] [blame] | 181 | ~JitCodeCache(); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 182 | |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame] | 183 | bool NotifyCompilationOf(ArtMethod* method, |
| 184 | Thread* self, |
| 185 | bool osr, |
| 186 | bool prejit, |
Nicolas Geoffray | a59af8a | 2019-11-27 17:42:32 +0000 | [diff] [blame^] | 187 | bool baseline, |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame] | 188 | JitMemoryRegion* region) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 189 | REQUIRES_SHARED(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 190 | REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 191 | |
Alex Light | dba6148 | 2016-12-21 08:20:29 -0800 | [diff] [blame] | 192 | void NotifyMethodRedefined(ArtMethod* method) |
| 193 | REQUIRES(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 194 | REQUIRES(!Locks::jit_lock_); |
Alex Light | dba6148 | 2016-12-21 08:20:29 -0800 | [diff] [blame] | 195 | |
Nicolas Geoffray | 07e3ca9 | 2016-03-11 09:57:57 +0000 | [diff] [blame] | 196 | // Notify to the code cache that the compiler wants to use the |
| 197 | // profiling info of `method` to drive optimizations, |
| 198 | // and therefore ensure the returned profiling info object is not |
| 199 | // collected. |
| 200 | ProfilingInfo* NotifyCompilerUse(ArtMethod* method, Thread* self) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 201 | REQUIRES_SHARED(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 202 | REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | b6e20ae | 2016-03-07 14:29:04 +0000 | [diff] [blame] | 203 | |
buzbee | 454b3b6 | 2016-04-07 14:42:47 -0700 | [diff] [blame] | 204 | void DoneCompiling(ArtMethod* method, Thread* self, bool osr) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 205 | REQUIRES_SHARED(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 206 | REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 207 | |
Nicolas Geoffray | 07e3ca9 | 2016-03-11 09:57:57 +0000 | [diff] [blame] | 208 | void DoneCompilerUse(ArtMethod* method, Thread* self) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 209 | REQUIRES_SHARED(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 210 | REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | b6e20ae | 2016-03-07 14:29:04 +0000 | [diff] [blame] | 211 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 212 | // Return true if the code cache contains this pc. |
| 213 | bool ContainsPc(const void* pc) const; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 214 | |
Alex Light | 2d441b1 | 2018-06-08 15:33:21 -0700 | [diff] [blame] | 215 | // Returns true if either the method's entrypoint is JIT compiled code or it is the |
| 216 | // instrumentation entrypoint and we can jump to jit code for this method. For testing use only. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 217 | bool WillExecuteJitCode(ArtMethod* method) REQUIRES(!Locks::jit_lock_); |
Alex Light | 2d441b1 | 2018-06-08 15:33:21 -0700 | [diff] [blame] | 218 | |
Nicolas Geoffray | a5891e8 | 2015-11-06 14:18:27 +0000 | [diff] [blame] | 219 | // Return true if the code cache contains this method. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 220 | bool ContainsMethod(ArtMethod* method) REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | a5891e8 | 2015-11-06 14:18:27 +0000 | [diff] [blame] | 221 | |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 222 | // Return the code pointer for a JNI-compiled stub if the method is in the cache, null otherwise. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 223 | const void* GetJniStubCode(ArtMethod* method) REQUIRES(!Locks::jit_lock_); |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 224 | |
David Srbecky | adb66f9 | 2019-10-10 12:59:43 +0000 | [diff] [blame] | 225 | // Allocate a region for both code and data in the JIT code cache. |
| 226 | // The reserved memory is left completely uninitialized. |
| 227 | bool Reserve(Thread* self, |
| 228 | JitMemoryRegion* region, |
| 229 | size_t code_size, |
| 230 | size_t stack_map_size, |
| 231 | size_t number_of_roots, |
| 232 | ArtMethod* method, |
| 233 | /*out*/ArrayRef<const uint8_t>* reserved_code, |
| 234 | /*out*/ArrayRef<const uint8_t>* reserved_data) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 235 | REQUIRES_SHARED(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 236 | REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | 5550ca8 | 2015-08-21 18:38:30 +0100 | [diff] [blame] | 237 | |
David Srbecky | adb66f9 | 2019-10-10 12:59:43 +0000 | [diff] [blame] | 238 | // Initialize code and data of previously allocated memory. |
| 239 | // |
| 240 | // `cha_single_implementation_list` needs to be registered via CHA (if it's |
| 241 | // still valid), since the compiled code still needs to be invalidated if the |
| 242 | // single-implementation assumptions are violated later. This needs to be done |
| 243 | // even if `has_should_deoptimize_flag` is false, which can happen due to CHA |
| 244 | // guard elimination. |
| 245 | bool Commit(Thread* self, |
| 246 | JitMemoryRegion* region, |
| 247 | ArtMethod* method, |
| 248 | ArrayRef<const uint8_t> reserved_code, // Uninitialized destination. |
| 249 | ArrayRef<const uint8_t> code, // Compiler output (source). |
| 250 | ArrayRef<const uint8_t> reserved_data, // Uninitialized destination. |
| 251 | const std::vector<Handle<mirror::Object>>& roots, |
| 252 | ArrayRef<const uint8_t> stack_map, // Compiler output (source). |
| 253 | bool osr, |
| 254 | bool has_should_deoptimize_flag, |
| 255 | const ArenaSet<ArtMethod*>& cha_single_implementation_list) |
| 256 | REQUIRES_SHARED(Locks::mutator_lock_) |
| 257 | REQUIRES(!Locks::jit_lock_); |
| 258 | |
| 259 | // Free the previously allocated memory regions. |
| 260 | void Free(Thread* self, JitMemoryRegion* region, const uint8_t* code, const uint8_t* data) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 261 | REQUIRES_SHARED(Locks::mutator_lock_) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 262 | REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | d28b969 | 2015-11-04 14:36:55 +0000 | [diff] [blame] | 263 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 264 | // Perform a collection on the code cache. |
| 265 | void GarbageCollectCache(Thread* self) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 266 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 267 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 268 | |
| 269 | // Given the 'pc', try to find the JIT compiled code associated with it. |
| 270 | // Return null if 'pc' is not in the code cache. 'method' is passed for |
| 271 | // sanity check. |
| 272 | OatQuickMethodHeader* LookupMethodHeader(uintptr_t pc, ArtMethod* method) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 273 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 274 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 275 | |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 276 | OatQuickMethodHeader* LookupOsrMethodHeader(ArtMethod* method) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 277 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 278 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 279 | |
Orion Hodson | eced692 | 2017-06-01 10:54:28 +0100 | [diff] [blame] | 280 | // Removes method from the cache for testing purposes. The caller |
| 281 | // must ensure that all threads are suspended and the method should |
| 282 | // not be in any thread's stack. |
| 283 | bool RemoveMethod(ArtMethod* method, bool release_memory) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 284 | REQUIRES(!Locks::jit_lock_) |
Orion Hodson | eced692 | 2017-06-01 10:54:28 +0100 | [diff] [blame] | 285 | REQUIRES(Locks::mutator_lock_); |
| 286 | |
Nicolas Geoffray | 26705e2 | 2015-10-28 12:50:11 +0000 | [diff] [blame] | 287 | // Remove all methods in our cache that were allocated by 'alloc'. |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 288 | void RemoveMethodsIn(Thread* self, const LinearAlloc& alloc) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 289 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 290 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 291 | |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 292 | void CopyInlineCacheInto(const InlineCache& ic, Handle<mirror::ObjectArray<mirror::Class>> array) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 293 | REQUIRES(!Locks::jit_lock_) |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 294 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | b6e20ae | 2016-03-07 14:29:04 +0000 | [diff] [blame] | 295 | |
Nicolas Geoffray | 26705e2 | 2015-10-28 12:50:11 +0000 | [diff] [blame] | 296 | // Create a 'ProfileInfo' for 'method'. If 'retry_allocation' is true, |
| 297 | // will collect and retry if the first allocation is unsuccessful. |
| 298 | ProfilingInfo* AddProfilingInfo(Thread* self, |
| 299 | ArtMethod* method, |
| 300 | const std::vector<uint32_t>& entries, |
| 301 | bool retry_allocation) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 302 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 303 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 26705e2 | 2015-10-28 12:50:11 +0000 | [diff] [blame] | 304 | |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 305 | bool OwnsSpace(const void* mspace) const NO_THREAD_SAFETY_ANALYSIS { |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame] | 306 | return private_region_.OwnsSpace(mspace) || shared_region_.OwnsSpace(mspace); |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 307 | } |
| 308 | |
| 309 | void* MoreCore(const void* mspace, intptr_t increment); |
| 310 | |
Calin Juravle | 9962962 | 2016-04-19 16:33:46 +0100 | [diff] [blame] | 311 | // Adds to `methods` all profiled methods which are part of any of the given dex locations. |
| 312 | void GetProfiledMethods(const std::set<std::string>& dex_base_locations, |
Calin Juravle | 940eb0c | 2017-01-30 19:30:44 -0800 | [diff] [blame] | 313 | std::vector<ProfileMethodInfo>& methods) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 314 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 315 | REQUIRES_SHARED(Locks::mutator_lock_); |
Calin Juravle | 31f2c15 | 2015-10-23 17:56:15 +0100 | [diff] [blame] | 316 | |
Nicolas Geoffray | 4ac0e15 | 2019-09-18 06:14:50 +0000 | [diff] [blame] | 317 | void InvalidateAllCompiledCode() |
| 318 | REQUIRES(!Locks::jit_lock_) |
| 319 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 320 | |
Nicolas Geoffray | b88d59e | 2016-02-17 11:31:49 +0000 | [diff] [blame] | 321 | void InvalidateCompiledCodeFor(ArtMethod* method, const OatQuickMethodHeader* code) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 322 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 323 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | b88d59e | 2016-02-17 11:31:49 +0000 | [diff] [blame] | 324 | |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 325 | void Dump(std::ostream& os) REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | bcd94c8 | 2016-03-03 13:23:33 +0000 | [diff] [blame] | 326 | |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 327 | bool IsOsrCompiled(ArtMethod* method) REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | 71cd50f | 2016-04-14 15:00:33 +0100 | [diff] [blame] | 328 | |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 329 | void SweepRootTables(IsMarkedVisitor* visitor) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 330 | REQUIRES(!Locks::jit_lock_) |
Nicolas Geoffray | 132d836 | 2016-11-16 09:19:42 +0000 | [diff] [blame] | 331 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 332 | |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 333 | // The GC needs to disallow the reading of inline caches when it processes them, |
| 334 | // to avoid having a class being used while it is being deleted. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 335 | void AllowInlineCacheAccess() REQUIRES(!Locks::jit_lock_); |
| 336 | void DisallowInlineCacheAccess() REQUIRES(!Locks::jit_lock_); |
| 337 | void BroadcastForInlineCacheAccess() REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 338 | |
Alex Light | dba6148 | 2016-12-21 08:20:29 -0800 | [diff] [blame] | 339 | // Notify the code cache that the method at the pointer 'old_method' is being moved to the pointer |
| 340 | // 'new_method' since it is being made obsolete. |
| 341 | void MoveObsoleteMethod(ArtMethod* old_method, ArtMethod* new_method) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 342 | REQUIRES(!Locks::jit_lock_) REQUIRES(Locks::mutator_lock_); |
Alex Light | dba6148 | 2016-12-21 08:20:29 -0800 | [diff] [blame] | 343 | |
Nicolas Geoffray | 226805d | 2018-12-14 10:59:02 +0000 | [diff] [blame] | 344 | // Dynamically change whether we want to garbage collect code. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 345 | void SetGarbageCollectCode(bool value) REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | 169722b | 2017-02-27 14:01:59 +0000 | [diff] [blame] | 346 | |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 347 | bool GetGarbageCollectCode() REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | 226805d | 2018-12-14 10:59:02 +0000 | [diff] [blame] | 348 | |
| 349 | // Unsafe variant for debug checks. |
| 350 | bool GetGarbageCollectCodeUnsafe() const NO_THREAD_SAFETY_ANALYSIS { |
Alex Light | 2d441b1 | 2018-06-08 15:33:21 -0700 | [diff] [blame] | 351 | return garbage_collect_code_; |
| 352 | } |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 353 | ZygoteMap* GetZygoteMap() { |
| 354 | return &zygote_map_; |
| 355 | } |
Alex Light | 2d441b1 | 2018-06-08 15:33:21 -0700 | [diff] [blame] | 356 | |
| 357 | // If Jit-gc has been disabled (and instrumentation has been enabled) this will return the |
| 358 | // jit-compiled entrypoint for this method. Otherwise it will return null. |
| 359 | const void* FindCompiledCodeForInstrumentation(ArtMethod* method) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 360 | REQUIRES(!Locks::jit_lock_) |
Alex Light | 2d441b1 | 2018-06-08 15:33:21 -0700 | [diff] [blame] | 361 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 362 | |
Nicolas Geoffray | 3238440 | 2019-07-17 20:06:44 +0100 | [diff] [blame] | 363 | // Fetch the code of a method that was JITted, but the JIT could not |
| 364 | // update its entrypoint due to the resolution trampoline. |
| 365 | const void* GetSavedEntryPointOfPreCompiledMethod(ArtMethod* method) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 366 | REQUIRES(!Locks::jit_lock_) |
Nicolas Geoffray | 7989ac9 | 2019-04-10 12:42:30 +0100 | [diff] [blame] | 367 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 368 | |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 369 | void PostForkChildAction(bool is_system_server, bool is_zygote); |
| 370 | |
Nicolas Geoffray | 226805d | 2018-12-14 10:59:02 +0000 | [diff] [blame] | 371 | // Clear the entrypoints of JIT compiled methods that belong in the zygote space. |
| 372 | // This is used for removing non-debuggable JIT code at the point we realize the runtime |
| 373 | // is debuggable. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 374 | void ClearEntryPointsInZygoteExecSpace() REQUIRES(!Locks::jit_lock_) REQUIRES(Locks::mutator_lock_); |
Nicolas Geoffray | 226805d | 2018-12-14 10:59:02 +0000 | [diff] [blame] | 375 | |
Nicolas Geoffray | a48c3df | 2019-06-27 13:11:12 +0000 | [diff] [blame] | 376 | JitMemoryRegion* GetCurrentRegion(); |
| 377 | bool IsSharedRegion(const JitMemoryRegion& region) const { return ®ion == &shared_region_; } |
| 378 | bool CanAllocateProfilingInfo() { |
| 379 | // If we don't have a private region, we cannot allocate a profiling info. |
| 380 | // A shared region doesn't support in general GC objects, which a profiling info |
| 381 | // can reference. |
| 382 | JitMemoryRegion* region = GetCurrentRegion(); |
| 383 | return region->IsValid() && !IsSharedRegion(*region); |
| 384 | } |
Nicolas Geoffray | 7f7539b | 2019-06-06 16:20:54 +0100 | [diff] [blame] | 385 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 386 | private: |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 387 | JitCodeCache(); |
| 388 | |
Nicolas Geoffray | 26705e2 | 2015-10-28 12:50:11 +0000 | [diff] [blame] | 389 | ProfilingInfo* AddProfilingInfoInternal(Thread* self, |
| 390 | ArtMethod* method, |
| 391 | const std::vector<uint32_t>& entries) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 392 | REQUIRES(Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 393 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 26705e2 | 2015-10-28 12:50:11 +0000 | [diff] [blame] | 394 | |
Alex Light | 33b7b5d | 2018-08-07 19:13:51 +0000 | [diff] [blame] | 395 | // If a collection is in progress, wait for it to finish. Must be called with the mutator lock. |
| 396 | // The non-mutator lock version should be used if possible. This method will release then |
| 397 | // re-acquire the mutator lock. |
| 398 | void WaitForPotentialCollectionToCompleteRunnable(Thread* self) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 399 | REQUIRES(Locks::jit_lock_, !Roles::uninterruptible_) REQUIRES_SHARED(Locks::mutator_lock_); |
Alex Light | 33b7b5d | 2018-08-07 19:13:51 +0000 | [diff] [blame] | 400 | |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 401 | // If a collection is in progress, wait for it to finish. Return |
| 402 | // whether the thread actually waited. |
| 403 | bool WaitForPotentialCollectionToComplete(Thread* self) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 404 | REQUIRES(Locks::jit_lock_) REQUIRES(!Locks::mutator_lock_); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 405 | |
Mingyao Yang | 063fc77 | 2016-08-02 11:02:54 -0700 | [diff] [blame] | 406 | // Remove CHA dependents and underlying allocations for entries in `method_headers`. |
| 407 | void FreeAllMethodHeaders(const std::unordered_set<OatQuickMethodHeader*>& method_headers) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 408 | REQUIRES(!Locks::jit_lock_) |
Mingyao Yang | 063fc77 | 2016-08-02 11:02:54 -0700 | [diff] [blame] | 409 | REQUIRES(!Locks::cha_lock_); |
| 410 | |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 411 | // Removes method from the cache. The caller must ensure that all threads |
| 412 | // are suspended and the method should not be in any thread's stack. |
| 413 | bool RemoveMethodLocked(ArtMethod* method, bool release_memory) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 414 | REQUIRES(Locks::jit_lock_) |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 415 | REQUIRES(Locks::mutator_lock_); |
| 416 | |
Orion Hodson | 607624f | 2018-05-11 10:10:46 +0100 | [diff] [blame] | 417 | // Free code and data allocations for `code_ptr`. |
David Srbecky | 8fc2f95 | 2019-07-31 18:40:09 +0100 | [diff] [blame] | 418 | void FreeCodeAndData(const void* code_ptr, bool free_debug_info = true) |
| 419 | REQUIRES(Locks::jit_lock_); |
Nicolas Geoffray | 1dad3f6 | 2015-10-23 14:59:54 +0100 | [diff] [blame] | 420 | |
Nicolas Geoffray | a5891e8 | 2015-11-06 14:18:27 +0000 | [diff] [blame] | 421 | // Number of bytes allocated in the code cache. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 422 | size_t CodeCacheSize() REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | b9f1af5 | 2018-11-16 10:30:29 +0000 | [diff] [blame] | 423 | |
| 424 | // Number of bytes allocated in the data cache. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 425 | size_t DataCacheSize() REQUIRES(!Locks::jit_lock_); |
Nicolas Geoffray | b9f1af5 | 2018-11-16 10:30:29 +0000 | [diff] [blame] | 426 | |
| 427 | // Number of bytes allocated in the code cache. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 428 | size_t CodeCacheSizeLocked() REQUIRES(Locks::jit_lock_); |
Nicolas Geoffray | a5891e8 | 2015-11-06 14:18:27 +0000 | [diff] [blame] | 429 | |
| 430 | // Number of bytes allocated in the data cache. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 431 | size_t DataCacheSizeLocked() REQUIRES(Locks::jit_lock_); |
Nicolas Geoffray | a5891e8 | 2015-11-06 14:18:27 +0000 | [diff] [blame] | 432 | |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 433 | // Notify all waiting threads that a collection is done. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 434 | void NotifyCollectionDone(Thread* self) REQUIRES(Locks::jit_lock_); |
Nicolas Geoffray | 0a3be16 | 2015-11-18 11:15:22 +0000 | [diff] [blame] | 435 | |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 436 | // Return whether we should do a full collection given the current state of the cache. |
| 437 | bool ShouldDoFullCollection() |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 438 | REQUIRES(Locks::jit_lock_) |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 439 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 440 | |
Nicolas Geoffray | 3512244 | 2016-03-02 12:05:30 +0000 | [diff] [blame] | 441 | void DoCollection(Thread* self, bool collect_profiling_info) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 442 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 443 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 8d37250 | 2016-02-23 13:56:43 +0000 | [diff] [blame] | 444 | |
Nicolas Geoffray | 9abb297 | 2016-03-04 14:32:59 +0000 | [diff] [blame] | 445 | void RemoveUnmarkedCode(Thread* self) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 446 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 447 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 8d37250 | 2016-02-23 13:56:43 +0000 | [diff] [blame] | 448 | |
| 449 | void MarkCompiledCodeOnThreadStacks(Thread* self) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 450 | REQUIRES(!Locks::jit_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 451 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 8d37250 | 2016-02-23 13:56:43 +0000 | [diff] [blame] | 452 | |
Nicolas Geoffray | b9f1af5 | 2018-11-16 10:30:29 +0000 | [diff] [blame] | 453 | CodeCacheBitmap* GetLiveBitmap() const { |
| 454 | return live_bitmap_.get(); |
| 455 | } |
| 456 | |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 457 | bool IsInZygoteDataSpace(const void* ptr) const { |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 458 | return shared_region_.IsInDataSpace(ptr); |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 459 | } |
| 460 | |
| 461 | bool IsInZygoteExecSpace(const void* ptr) const { |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 462 | return shared_region_.IsInExecSpace(ptr); |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 463 | } |
| 464 | |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 465 | bool IsWeakAccessEnabled(Thread* self) const; |
| 466 | void WaitUntilInlineCacheAccessible(Thread* self) |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 467 | REQUIRES(!Locks::jit_lock_) |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 468 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 469 | |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 470 | class JniStubKey; |
| 471 | class JniStubData; |
| 472 | |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 473 | // Whether the GC allows accessing weaks in inline caches. Note that this |
| 474 | // is not used by the concurrent collector, which uses |
| 475 | // Thread::SetWeakRefAccessEnabled instead. |
| 476 | Atomic<bool> is_weak_access_enabled_; |
| 477 | |
| 478 | // Condition to wait on for accessing inline caches. |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 479 | ConditionVariable inline_cache_cond_ GUARDED_BY(Locks::jit_lock_); |
Nicolas Geoffray | e51ca8b | 2016-11-22 14:49:31 +0000 | [diff] [blame] | 480 | |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 481 | // -------------- JIT memory regions ------------------------------------- // |
| 482 | |
| 483 | // Shared region, inherited from the zygote. |
| 484 | JitMemoryRegion shared_region_; |
| 485 | |
| 486 | // Process's own region. |
| 487 | JitMemoryRegion private_region_; |
| 488 | |
| 489 | // -------------- Global JIT maps --------------------------------------- // |
| 490 | |
| 491 | // Holds compiled code associated with the shorty for a JNI stub. |
| 492 | SafeMap<JniStubKey, JniStubData> jni_stubs_map_ GUARDED_BY(Locks::jit_lock_); |
| 493 | |
| 494 | // Holds compiled code associated to the ArtMethod. |
| 495 | SafeMap<const void*, ArtMethod*> method_code_map_ GUARDED_BY(Locks::jit_lock_); |
| 496 | |
Nicolas Geoffray | 3238440 | 2019-07-17 20:06:44 +0100 | [diff] [blame] | 497 | // Holds compiled code associated to the ArtMethod. Used when pre-jitting |
| 498 | // methods whose entrypoints have the resolution stub. |
| 499 | SafeMap<ArtMethod*, const void*> saved_compiled_methods_map_ GUARDED_BY(Locks::jit_lock_); |
| 500 | |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 501 | // Holds osr compiled code associated to the ArtMethod. |
| 502 | SafeMap<ArtMethod*, const void*> osr_code_map_ GUARDED_BY(Locks::jit_lock_); |
| 503 | |
| 504 | // ProfilingInfo objects we have allocated. |
| 505 | std::vector<ProfilingInfo*> profiling_infos_ GUARDED_BY(Locks::jit_lock_); |
| 506 | |
Nicolas Geoffray | e32d24c | 2019-07-05 10:28:59 +0100 | [diff] [blame] | 507 | // Methods that the zygote has compiled and can be shared across processes |
| 508 | // forked from the zygote. |
| 509 | ZygoteMap zygote_map_; |
| 510 | |
Nicolas Geoffray | 2a905b2 | 2019-06-06 09:04:07 +0100 | [diff] [blame] | 511 | // -------------- JIT GC related data structures ----------------------- // |
| 512 | |
| 513 | // Condition to wait on during collection. |
| 514 | ConditionVariable lock_cond_ GUARDED_BY(Locks::jit_lock_); |
| 515 | |
| 516 | // Whether there is a code cache collection in progress. |
| 517 | bool collection_in_progress_ GUARDED_BY(Locks::jit_lock_); |
| 518 | |
| 519 | // Bitmap for collecting code and data. |
| 520 | std::unique_ptr<CodeCacheBitmap> live_bitmap_; |
| 521 | |
| 522 | // Whether the last collection round increased the code cache. |
| 523 | bool last_collection_increased_code_cache_ GUARDED_BY(Locks::jit_lock_); |
| 524 | |
| 525 | // Whether we can do garbage collection. Not 'const' as tests may override this. |
| 526 | bool garbage_collect_code_ GUARDED_BY(Locks::jit_lock_); |
| 527 | |
| 528 | // ---------------- JIT statistics -------------------------------------- // |
| 529 | |
| 530 | // Number of compilations done throughout the lifetime of the JIT. |
| 531 | size_t number_of_compilations_ GUARDED_BY(Locks::jit_lock_); |
| 532 | |
| 533 | // Number of compilations for on-stack-replacement done throughout the lifetime of the JIT. |
| 534 | size_t number_of_osr_compilations_ GUARDED_BY(Locks::jit_lock_); |
| 535 | |
| 536 | // Number of code cache collections done throughout the lifetime of the JIT. |
| 537 | size_t number_of_collections_ GUARDED_BY(Locks::jit_lock_); |
| 538 | |
| 539 | // Histograms for keeping track of stack map size statistics. |
| 540 | Histogram<uint64_t> histogram_stack_map_memory_use_ GUARDED_BY(Locks::jit_lock_); |
| 541 | |
| 542 | // Histograms for keeping track of code size statistics. |
| 543 | Histogram<uint64_t> histogram_code_memory_use_ GUARDED_BY(Locks::jit_lock_); |
| 544 | |
| 545 | // Histograms for keeping track of profiling info statistics. |
| 546 | Histogram<uint64_t> histogram_profiling_info_memory_use_ GUARDED_BY(Locks::jit_lock_); |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 547 | |
Vladimir Marko | 2196c65 | 2017-11-30 16:16:07 +0000 | [diff] [blame] | 548 | friend class art::JitJniStubTestHelper; |
Calin Juravle | 016fcbe2 | 2018-05-03 19:47:35 -0700 | [diff] [blame] | 549 | friend class ScopedCodeCacheWrite; |
Nicolas Geoffray | ce9ed36 | 2018-11-29 03:19:28 +0000 | [diff] [blame] | 550 | friend class MarkCodeClosure; |
Calin Juravle | 016fcbe2 | 2018-05-03 19:47:35 -0700 | [diff] [blame] | 551 | |
Nicolas Geoffray | c9de61c | 2018-11-27 17:34:31 +0000 | [diff] [blame] | 552 | DISALLOW_COPY_AND_ASSIGN(JitCodeCache); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 553 | }; |
| 554 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 555 | } // namespace jit |
| 556 | } // namespace art |
| 557 | |
| 558 | #endif // ART_RUNTIME_JIT_JIT_CODE_CACHE_H_ |