blob: 7a838fddd63d380523f00df1b770cdc071b5f40d [file] [log] [blame]
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001/*
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 Gampef0f3c592018-06-26 13:28:00 -070020#include <iosfwd>
21#include <memory>
22#include <set>
23#include <string>
24#include <unordered_set>
25#include <vector>
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080026
Mingyao Yang063fc772016-08-02 11:02:54 -070027#include "base/arena_containers.h"
David Sehrc431b9d2018-03-02 12:01:51 -080028#include "base/atomic.h"
Andreas Gampef0f3c592018-06-26 13:28:00 -070029#include "base/histogram.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080030#include "base/macros.h"
Vladimir Markoc34bebf2018-08-16 16:12:49 +010031#include "base/mem_map.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080032#include "base/mutex.h"
David Sehr67bf42e2018-02-26 16:43:04 -080033#include "base/safe_map.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080034
35namespace art {
36
Mathieu Chartiere401d142015-04-22 13:56:20 -070037class ArtMethod;
Vladimir Markob0b68cf2017-11-14 18:11:50 +000038template<class T> class Handle;
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +010039class LinearAlloc;
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +000040class InlineCache;
Andreas Gampe5d08fcc2017-06-05 17:56:46 -070041class IsMarkedVisitor;
Vladimir Marko2196c652017-11-30 16:16:07 +000042class JitJniStubTestHelper;
Andreas Gampe513061a2017-06-01 09:17:34 -070043class OatQuickMethodHeader;
Vladimir Markob0b68cf2017-11-14 18:11:50 +000044struct ProfileMethodInfo;
Nicolas Geoffray26705e22015-10-28 12:50:11 +000045class ProfilingInfo;
Vladimir Marko2196c652017-11-30 16:16:07 +000046class Thread;
47
48namespace gc {
49namespace accounting {
50template<size_t kAlignment> class MemoryRangeBitmap;
51} // namespace accounting
52} // namespace gc
53
54namespace mirror {
55class Class;
56class Object;
57template<class T> class ObjectArray;
58} // namespace mirror
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080059
Vladimir Markob0b68cf2017-11-14 18:11:50 +000060namespace gc {
61namespace accounting {
62template<size_t kAlignment> class MemoryRangeBitmap;
63} // namespace accounting
64} // namespace gc
65
66namespace mirror {
67class Class;
68class Object;
69template<class T> class ObjectArray;
70} // namespace mirror
71
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080072namespace jit {
73
Calin Juravle016fcbe22018-05-03 19:47:35 -070074class ScopedCodeCacheWrite;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080075
Nicolas Geoffray0a3be162015-11-18 11:15:22 +000076// Alignment in bits that will suit all architectures.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +010077static constexpr int kJitCodeAlignment = 16;
78using CodeCacheBitmap = gc::accounting::MemoryRangeBitmap<kJitCodeAlignment>;
79
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080080class JitCodeCache {
81 public:
Nicolas Geoffray0a3be162015-11-18 11:15:22 +000082 static constexpr size_t kMaxCapacity = 64 * MB;
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +010083 // Put the default to a very low amount for debug builds to stress the code cache
84 // collection.
Nicolas Geoffray7ca4b772016-02-23 13:52:01 +000085 static constexpr size_t kInitialCapacity = kIsDebugBuild ? 8 * KB : 64 * KB;
Nicolas Geoffray65b83d82016-02-22 13:14:04 +000086
87 // By default, do not GC until reaching 256KB.
88 static constexpr size_t kReservedCapacity = kInitialCapacity * 4;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080089
Mathieu Chartierbce416f2015-03-23 12:37:35 -070090 // Create the code cache with a code + data capacity equal to "capacity", error message is passed
91 // in the out arg error_msg.
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +000092 static JitCodeCache* Create(bool used_only_for_profile_data,
Orion Hodsonad28f5e2018-10-17 09:08:17 +010093 bool rwx_memory_allowed,
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +000094 bool is_zygote,
Nicolas Geoffraya25dce92016-01-12 16:41:10 +000095 std::string* error_msg);
Vladimir Markob0b68cf2017-11-14 18:11:50 +000096 ~JitCodeCache();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080097
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +000098 bool NotifyCompilationOf(ArtMethod* method, Thread* self, bool osr)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -070099 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100100 REQUIRES(!lock_);
101
Alex Lightdba61482016-12-21 08:20:29 -0800102 void NotifyMethodRedefined(ArtMethod* method)
103 REQUIRES(Locks::mutator_lock_)
104 REQUIRES(!lock_);
105
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000106 // Notify to the code cache that the compiler wants to use the
107 // profiling info of `method` to drive optimizations,
108 // and therefore ensure the returned profiling info object is not
109 // collected.
110 ProfilingInfo* NotifyCompilerUse(ArtMethod* method, Thread* self)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700111 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000112 REQUIRES(!lock_);
113
buzbee454b3b62016-04-07 14:42:47 -0700114 void DoneCompiling(ArtMethod* method, Thread* self, bool osr)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700115 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100116 REQUIRES(!lock_);
117
Nicolas Geoffray07e3ca92016-03-11 09:57:57 +0000118 void DoneCompilerUse(ArtMethod* method, Thread* self)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700119 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000120 REQUIRES(!lock_);
121
Nicolas Geoffray0c3c2662015-10-15 13:53:04 +0100122 // Allocate and write code and its metadata to the code cache.
Mingyao Yang063fc772016-08-02 11:02:54 -0700123 // `cha_single_implementation_list` needs to be registered via CHA (if it's
124 // still valid), since the compiled code still needs to be invalidated if the
125 // single-implementation assumptions are violated later. This needs to be done
126 // even if `has_should_deoptimize_flag` is false, which can happen due to CHA
127 // guard elimination.
Nicolas Geoffray0c3c2662015-10-15 13:53:04 +0100128 uint8_t* CommitCode(Thread* self,
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100129 ArtMethod* method,
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000130 uint8_t* stack_map,
131 uint8_t* roots_data,
Nicolas Geoffray0c3c2662015-10-15 13:53:04 +0100132 const uint8_t* code,
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000133 size_t code_size,
Orion Hodsondbd05fe2017-08-10 11:41:35 +0100134 size_t data_size,
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000135 bool osr,
Vladimir Markoac3ac682018-09-20 11:01:43 +0100136 const std::vector<Handle<mirror::Object>>& roots,
Mingyao Yang063fc772016-08-02 11:02:54 -0700137 bool has_should_deoptimize_flag,
138 const ArenaSet<ArtMethod*>& cha_single_implementation_list)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700139 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray0c3c2662015-10-15 13:53:04 +0100140 REQUIRES(!lock_);
141
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100142 // Return true if the code cache contains this pc.
143 bool ContainsPc(const void* pc) const;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800144
Alex Light2d441b12018-06-08 15:33:21 -0700145 // Returns true if either the method's entrypoint is JIT compiled code or it is the
146 // instrumentation entrypoint and we can jump to jit code for this method. For testing use only.
147 bool WillExecuteJitCode(ArtMethod* method) REQUIRES(!lock_);
148
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000149 // Return true if the code cache contains this method.
150 bool ContainsMethod(ArtMethod* method) REQUIRES(!lock_);
151
Vladimir Marko2196c652017-11-30 16:16:07 +0000152 // Return the code pointer for a JNI-compiled stub if the method is in the cache, null otherwise.
153 const void* GetJniStubCode(ArtMethod* method) REQUIRES(!lock_);
154
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000155 // Allocate a region of data that contain `size` bytes, and potentially space
156 // for storing `number_of_roots` roots. Returns null if there is no more room.
Nicolas Geoffrayed015ac2016-12-15 17:58:48 +0000157 // Return the number of bytes allocated.
158 size_t ReserveData(Thread* self,
Mathieu Chartiercbcedbf2017-03-12 22:24:50 -0700159 size_t stack_map_size,
Nicolas Geoffrayed015ac2016-12-15 17:58:48 +0000160 size_t number_of_roots,
161 ArtMethod* method,
162 uint8_t** stack_map_data,
163 uint8_t** roots_data)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700164 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100165 REQUIRES(!lock_);
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100166
Nicolas Geoffrayd28b9692015-11-04 14:36:55 +0000167 // Clear data from the data portion of the code cache.
Nicolas Geoffrayf46501c2016-11-22 13:45:36 +0000168 void ClearData(Thread* self, uint8_t* stack_map_data, uint8_t* roots_data)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700169 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffrayd28b9692015-11-04 14:36:55 +0000170 REQUIRES(!lock_);
171
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100172 // Perform a collection on the code cache.
173 void GarbageCollectCache(Thread* self)
174 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700175 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100176
177 // Given the 'pc', try to find the JIT compiled code associated with it.
178 // Return null if 'pc' is not in the code cache. 'method' is passed for
179 // sanity check.
180 OatQuickMethodHeader* LookupMethodHeader(uintptr_t pc, ArtMethod* method)
181 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700182 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100183
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000184 OatQuickMethodHeader* LookupOsrMethodHeader(ArtMethod* method)
185 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700186 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000187
Orion Hodsoneced6922017-06-01 10:54:28 +0100188 // Removes method from the cache for testing purposes. The caller
189 // must ensure that all threads are suspended and the method should
190 // not be in any thread's stack.
191 bool RemoveMethod(ArtMethod* method, bool release_memory)
192 REQUIRES(!lock_)
193 REQUIRES(Locks::mutator_lock_);
194
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000195 // Remove all methods in our cache that were allocated by 'alloc'.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100196 void RemoveMethodsIn(Thread* self, const LinearAlloc& alloc)
197 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700198 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800199
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +0000200 void CopyInlineCacheInto(const InlineCache& ic, Handle<mirror::ObjectArray<mirror::Class>> array)
201 REQUIRES(!lock_)
202 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffrayb6e20ae2016-03-07 14:29:04 +0000203
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000204 // Create a 'ProfileInfo' for 'method'. If 'retry_allocation' is true,
205 // will collect and retry if the first allocation is unsuccessful.
206 ProfilingInfo* AddProfilingInfo(Thread* self,
207 ArtMethod* method,
208 const std::vector<uint32_t>& entries,
209 bool retry_allocation)
210 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700211 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000212
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000213 bool OwnsSpace(const void* mspace) const NO_THREAD_SAFETY_ANALYSIS {
Orion Hodson1d3fd082018-09-28 09:38:35 +0100214 return mspace == data_mspace_ || mspace == exec_mspace_;
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000215 }
216
217 void* MoreCore(const void* mspace, intptr_t increment);
218
Calin Juravle99629622016-04-19 16:33:46 +0100219 // Adds to `methods` all profiled methods which are part of any of the given dex locations.
220 void GetProfiledMethods(const std::set<std::string>& dex_base_locations,
Calin Juravle940eb0c2017-01-30 19:30:44 -0800221 std::vector<ProfileMethodInfo>& methods)
Calin Juravle31f2c152015-10-23 17:56:15 +0100222 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700223 REQUIRES_SHARED(Locks::mutator_lock_);
Calin Juravle31f2c152015-10-23 17:56:15 +0100224
Nicolas Geoffrayb88d59e2016-02-17 11:31:49 +0000225 void InvalidateCompiledCodeFor(ArtMethod* method, const OatQuickMethodHeader* code)
226 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700227 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffrayb88d59e2016-02-17 11:31:49 +0000228
Nicolas Geoffraybcd94c82016-03-03 13:23:33 +0000229 void Dump(std::ostream& os) REQUIRES(!lock_);
230
Nicolas Geoffray71cd50f2016-04-14 15:00:33 +0100231 bool IsOsrCompiled(ArtMethod* method) REQUIRES(!lock_);
232
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000233 void SweepRootTables(IsMarkedVisitor* visitor)
234 REQUIRES(!lock_)
235 REQUIRES_SHARED(Locks::mutator_lock_);
236
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +0000237 // The GC needs to disallow the reading of inline caches when it processes them,
238 // to avoid having a class being used while it is being deleted.
239 void AllowInlineCacheAccess() REQUIRES(!lock_);
240 void DisallowInlineCacheAccess() REQUIRES(!lock_);
241 void BroadcastForInlineCacheAccess() REQUIRES(!lock_);
242
Alex Lightdba61482016-12-21 08:20:29 -0800243 // Notify the code cache that the method at the pointer 'old_method' is being moved to the pointer
244 // 'new_method' since it is being made obsolete.
245 void MoveObsoleteMethod(ArtMethod* old_method, ArtMethod* new_method)
246 REQUIRES(!lock_) REQUIRES(Locks::mutator_lock_);
247
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100248 // Dynamically change whether we want to garbage collect code. Should only be used during JIT
249 // initialization or by tests.
Nicolas Geoffray169722b2017-02-27 14:01:59 +0000250 void SetGarbageCollectCode(bool value) {
251 garbage_collect_code_ = value;
252 }
253
Alex Light2d441b12018-06-08 15:33:21 -0700254 bool GetGarbageCollectCode() const {
255 return garbage_collect_code_;
256 }
257
258 // If Jit-gc has been disabled (and instrumentation has been enabled) this will return the
259 // jit-compiled entrypoint for this method. Otherwise it will return null.
260 const void* FindCompiledCodeForInstrumentation(ArtMethod* method)
261 REQUIRES(!lock_)
262 REQUIRES_SHARED(Locks::mutator_lock_);
263
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +0000264 void PostForkChildAction(bool is_system_server, bool is_zygote);
265
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800266 private:
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +0000267 JitCodeCache();
268
269 void InitializeState(size_t initial_capacity, size_t max_capacity) REQUIRES(lock_);
270
271 bool InitializeMappings(bool rwx_memory_allowed, bool is_zygote, std::string* error_msg)
272 REQUIRES(lock_);
273
274 void InitializeSpaces() REQUIRES(lock_);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800275
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100276 // Internal version of 'CommitCode' that will not retry if the
277 // allocation fails. Return null if the allocation fails.
278 uint8_t* CommitCodeInternal(Thread* self,
279 ArtMethod* method,
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000280 uint8_t* stack_map,
281 uint8_t* roots_data,
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100282 const uint8_t* code,
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000283 size_t code_size,
Orion Hodsondbd05fe2017-08-10 11:41:35 +0100284 size_t data_size,
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000285 bool osr,
Vladimir Markoac3ac682018-09-20 11:01:43 +0100286 const std::vector<Handle<mirror::Object>>& roots,
Mingyao Yang063fc772016-08-02 11:02:54 -0700287 bool has_should_deoptimize_flag,
288 const ArenaSet<ArtMethod*>& cha_single_implementation_list)
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100289 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700290 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100291
Alex Light3e36a9c2018-06-19 09:45:05 -0700292 // Adds the given roots to the roots_data. Only a member for annotalysis.
Vladimir Markoac3ac682018-09-20 11:01:43 +0100293 void FillRootTable(uint8_t* roots_data, const std::vector<Handle<mirror::Object>>& roots)
Alex Light3e36a9c2018-06-19 09:45:05 -0700294 REQUIRES(lock_)
295 REQUIRES_SHARED(Locks::mutator_lock_);
296
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000297 ProfilingInfo* AddProfilingInfoInternal(Thread* self,
298 ArtMethod* method,
299 const std::vector<uint32_t>& entries)
Nicolas Geoffray1e7da9b2016-03-01 14:11:40 +0000300 REQUIRES(lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700301 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000302
Alex Light33b7b5d2018-08-07 19:13:51 +0000303 // If a collection is in progress, wait for it to finish. Must be called with the mutator lock.
304 // The non-mutator lock version should be used if possible. This method will release then
305 // re-acquire the mutator lock.
306 void WaitForPotentialCollectionToCompleteRunnable(Thread* self)
307 REQUIRES(lock_, !Roles::uninterruptible_) REQUIRES_SHARED(Locks::mutator_lock_);
308
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100309 // If a collection is in progress, wait for it to finish. Return
310 // whether the thread actually waited.
311 bool WaitForPotentialCollectionToComplete(Thread* self)
312 REQUIRES(lock_) REQUIRES(!Locks::mutator_lock_);
313
Mingyao Yang063fc772016-08-02 11:02:54 -0700314 // Remove CHA dependents and underlying allocations for entries in `method_headers`.
315 void FreeAllMethodHeaders(const std::unordered_set<OatQuickMethodHeader*>& method_headers)
316 REQUIRES(!lock_)
317 REQUIRES(!Locks::cha_lock_);
318
Vladimir Marko2196c652017-11-30 16:16:07 +0000319 // Removes method from the cache. The caller must ensure that all threads
320 // are suspended and the method should not be in any thread's stack.
321 bool RemoveMethodLocked(ArtMethod* method, bool release_memory)
322 REQUIRES(lock_)
323 REQUIRES(Locks::mutator_lock_);
324
Orion Hodson607624f2018-05-11 10:10:46 +0100325 // Free code and data allocations for `code_ptr`.
326 void FreeCodeAndData(const void* code_ptr) REQUIRES(lock_);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100327
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000328 // Number of bytes allocated in the code cache.
Nicolas Geoffrayb9f1af52018-11-16 10:30:29 +0000329 size_t CodeCacheSize() REQUIRES(!lock_);
330
331 // Number of bytes allocated in the data cache.
332 size_t DataCacheSize() REQUIRES(!lock_);
333
334 // Number of bytes allocated in the code cache.
Nicolas Geoffraya5891e82015-11-06 14:18:27 +0000335 size_t CodeCacheSizeLocked() REQUIRES(lock_);
336
337 // Number of bytes allocated in the data cache.
338 size_t DataCacheSizeLocked() REQUIRES(lock_);
339
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000340 // Notify all waiting threads that a collection is done.
341 void NotifyCollectionDone(Thread* self) REQUIRES(lock_);
342
343 // Try to increase the current capacity of the code cache. Return whether we
344 // succeeded at doing so.
345 bool IncreaseCodeCacheCapacity() REQUIRES(lock_);
346
347 // Set the footprint limit of the code cache.
348 void SetFootprintLimit(size_t new_footprint) REQUIRES(lock_);
349
Vladimir Marko2196c652017-11-30 16:16:07 +0000350 // Return whether we should do a full collection given the current state of the cache.
351 bool ShouldDoFullCollection()
352 REQUIRES(lock_)
353 REQUIRES_SHARED(Locks::mutator_lock_);
354
Nicolas Geoffray35122442016-03-02 12:05:30 +0000355 void DoCollection(Thread* self, bool collect_profiling_info)
Nicolas Geoffray8d372502016-02-23 13:56:43 +0000356 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700357 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8d372502016-02-23 13:56:43 +0000358
Nicolas Geoffray9abb2972016-03-04 14:32:59 +0000359 void RemoveUnmarkedCode(Thread* self)
Nicolas Geoffray8d372502016-02-23 13:56:43 +0000360 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700361 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8d372502016-02-23 13:56:43 +0000362
363 void MarkCompiledCodeOnThreadStacks(Thread* self)
364 REQUIRES(!lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700365 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8d372502016-02-23 13:56:43 +0000366
Nicolas Geoffray35122442016-03-02 12:05:30 +0000367 bool CheckLiveCompiledCodeHasProfilingInfo()
Vladimir Markod1ee20f2017-08-17 09:21:16 +0000368 REQUIRES(lock_)
369 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray35122442016-03-02 12:05:30 +0000370
Nicolas Geoffrayb9f1af52018-11-16 10:30:29 +0000371 CodeCacheBitmap* GetLiveBitmap() const {
372 return live_bitmap_.get();
373 }
374
Nicolas Geoffraybcd94c82016-03-03 13:23:33 +0000375 uint8_t* AllocateCode(size_t code_size) REQUIRES(lock_);
Orion Hodson607624f2018-05-11 10:10:46 +0100376 void FreeCode(uint8_t* code) REQUIRES(lock_);
Nicolas Geoffraybcd94c82016-03-03 13:23:33 +0000377 uint8_t* AllocateData(size_t data_size) REQUIRES(lock_);
Orion Hodson607624f2018-05-11 10:10:46 +0100378 void FreeData(uint8_t* data) REQUIRES(lock_);
Nicolas Geoffraybcd94c82016-03-03 13:23:33 +0000379
Orion Hodson1d3fd082018-09-28 09:38:35 +0100380 bool HasDualCodeMapping() const {
381 return non_exec_pages_.IsValid();
382 }
383
384 bool HasCodeMapping() const {
385 return exec_pages_.IsValid();
386 }
387
388 const MemMap* GetUpdatableCodeMapping() const;
389
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +0000390 bool IsWeakAccessEnabled(Thread* self) const;
391 void WaitUntilInlineCacheAccessible(Thread* self)
392 REQUIRES(!lock_)
393 REQUIRES_SHARED(Locks::mutator_lock_);
394
Vladimir Marko2196c652017-11-30 16:16:07 +0000395 class JniStubKey;
396 class JniStubData;
397
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100398 // Lock for guarding allocations, collections, and the method_code_map_.
Alex Light3e36a9c2018-06-19 09:45:05 -0700399 Mutex lock_ BOTTOM_MUTEX_ACQUIRED_AFTER;
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100400 // Condition to wait on during collection.
401 ConditionVariable lock_cond_ GUARDED_BY(lock_);
402 // Whether there is a code cache collection in progress.
403 bool collection_in_progress_ GUARDED_BY(lock_);
Nicolas Geoffray0c3c2662015-10-15 13:53:04 +0100404 // Mem map which holds data (stack maps and profiling info).
Orion Hodson1d3fd082018-09-28 09:38:35 +0100405 MemMap data_pages_;
406 // Mem map which holds code and has executable permission.
407 MemMap exec_pages_;
408 // Mem map which holds code with non executable permission. Only valid for dual view JIT when
409 // this is the non-executable view of code used to write updates.
410 MemMap non_exec_pages_;
Nicolas Geoffray0c3c2662015-10-15 13:53:04 +0100411 // The opaque mspace for allocating data.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100412 void* data_mspace_ GUARDED_BY(lock_);
Orion Hodson1d3fd082018-09-28 09:38:35 +0100413 // The opaque mspace for allocating code.
414 void* exec_mspace_ GUARDED_BY(lock_);
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100415 // Bitmap for collecting code and data.
416 std::unique_ptr<CodeCacheBitmap> live_bitmap_;
Vladimir Marko2196c652017-11-30 16:16:07 +0000417 // Holds compiled code associated with the shorty for a JNI stub.
418 SafeMap<JniStubKey, JniStubData> jni_stubs_map_ GUARDED_BY(lock_);
Orion Hodsondbd05fe2017-08-10 11:41:35 +0100419 // Holds compiled code associated to the ArtMethod.
Nicolas Geoffray1dad3f62015-10-23 14:59:54 +0100420 SafeMap<const void*, ArtMethod*> method_code_map_ GUARDED_BY(lock_);
Orion Hodsondbd05fe2017-08-10 11:41:35 +0100421 // Holds osr compiled code associated to the ArtMethod.
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000422 SafeMap<ArtMethod*, const void*> osr_code_map_ GUARDED_BY(lock_);
Nicolas Geoffray26705e22015-10-28 12:50:11 +0000423 // ProfilingInfo objects we have allocated.
424 std::vector<ProfilingInfo*> profiling_infos_ GUARDED_BY(lock_);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800425
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +0000426 // The initial capacity in bytes this code cache starts with.
427 size_t initial_capacity_ GUARDED_BY(lock_);
428
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000429 // The maximum capacity in bytes this code cache can go to.
430 size_t max_capacity_ GUARDED_BY(lock_);
431
432 // The current capacity in bytes of the code cache.
433 size_t current_capacity_ GUARDED_BY(lock_);
434
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000435 // The current footprint in bytes of the data portion of the code cache.
436 size_t data_end_ GUARDED_BY(lock_);
437
Orion Hodson1d3fd082018-09-28 09:38:35 +0100438 // The current footprint in bytes of the code portion of the code cache.
439 size_t exec_end_ GUARDED_BY(lock_);
440
Nicolas Geoffray35122442016-03-02 12:05:30 +0000441 // Whether the last collection round increased the code cache.
442 bool last_collection_increased_code_cache_ GUARDED_BY(lock_);
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000443
Nicolas Geoffray169722b2017-02-27 14:01:59 +0000444 // Whether we can do garbage collection. Not 'const' as tests may override this.
445 bool garbage_collect_code_;
Nicolas Geoffraya25dce92016-01-12 16:41:10 +0000446
Nicolas Geoffray38ea9bd2016-02-19 16:25:57 +0000447 // The size in bytes of used memory for the data portion of the code cache.
448 size_t used_memory_for_data_ GUARDED_BY(lock_);
449
450 // The size in bytes of used memory for the code portion of the code cache.
451 size_t used_memory_for_code_ GUARDED_BY(lock_);
452
Nicolas Geoffray0a522232016-01-19 09:34:58 +0000453 // Number of compilations done throughout the lifetime of the JIT.
454 size_t number_of_compilations_ GUARDED_BY(lock_);
Nicolas Geoffraybcd94c82016-03-03 13:23:33 +0000455
456 // Number of compilations for on-stack-replacement done throughout the lifetime of the JIT.
Nicolas Geoffrayfcdd7292016-02-25 13:27:47 +0000457 size_t number_of_osr_compilations_ GUARDED_BY(lock_);
Nicolas Geoffray0a522232016-01-19 09:34:58 +0000458
Nicolas Geoffraybcd94c82016-03-03 13:23:33 +0000459 // Number of code cache collections done throughout the lifetime of the JIT.
460 size_t number_of_collections_ GUARDED_BY(lock_);
461
Nicolas Geoffray933330a2016-03-16 14:20:06 +0000462 // Histograms for keeping track of stack map size statistics.
463 Histogram<uint64_t> histogram_stack_map_memory_use_ GUARDED_BY(lock_);
464
465 // Histograms for keeping track of code size statistics.
466 Histogram<uint64_t> histogram_code_memory_use_ GUARDED_BY(lock_);
467
468 // Histograms for keeping track of profiling info statistics.
469 Histogram<uint64_t> histogram_profiling_info_memory_use_ GUARDED_BY(lock_);
470
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +0000471 // Whether the GC allows accessing weaks in inline caches. Note that this
472 // is not used by the concurrent collector, which uses
473 // Thread::SetWeakRefAccessEnabled instead.
474 Atomic<bool> is_weak_access_enabled_;
475
476 // Condition to wait on for accessing inline caches.
477 ConditionVariable inline_cache_cond_ GUARDED_BY(lock_);
478
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +0000479 // Mem map which holds zygote data (stack maps and profiling info).
480 MemMap zygote_data_pages_;
481 // Mem map which holds zygote code and has executable permission.
482 MemMap zygote_exec_pages_;
483 // The opaque mspace for allocating zygote data.
484 void* zygote_data_mspace_ GUARDED_BY(lock_);
485 // The opaque mspace for allocating zygote code.
486 void* zygote_exec_mspace_ GUARDED_BY(lock_);
487
Vladimir Marko2196c652017-11-30 16:16:07 +0000488 friend class art::JitJniStubTestHelper;
Calin Juravle016fcbe22018-05-03 19:47:35 -0700489 friend class ScopedCodeCacheWrite;
490
Nicolas Geoffrayc9de61c2018-11-27 17:34:31 +0000491 DISALLOW_COPY_AND_ASSIGN(JitCodeCache);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800492};
493
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800494} // namespace jit
495} // namespace art
496
497#endif // ART_RUNTIME_JIT_JIT_CODE_CACHE_H_