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 20 #include "instrumentation.h" 21 22 #include "atomic.h" 23 #include "base/histogram-inl.h" 24 #include "base/macros.h" 25 #include "base/mutex.h" 26 #include "gc/accounting/bitmap.h" 27 #include "gc_root.h" 28 #include "jni.h" 29 #include "method_reference.h" 30 #include "oat_file.h" 31 #include "object_callbacks.h" 32 #include "safe_map.h" 33 #include "thread_pool.h" 34 35 namespace art { 36 37 class ArtMethod; 38 class LinearAlloc; 39 class ProfilingInfo; 40 41 namespace jit { 42 43 class JitInstrumentationCache; 44 45 // Alignment in bits that will suit all architectures. 46 static constexpr int kJitCodeAlignment = 16; 47 using CodeCacheBitmap = gc::accounting::MemoryRangeBitmap<kJitCodeAlignment>; 48 49 class JitCodeCache { 50 public: 51 static constexpr size_t kMaxCapacity = 64 * MB; 52 // Put the default to a very low amount for debug builds to stress the code cache 53 // collection. 54 static constexpr size_t kInitialCapacity = kIsDebugBuild ? 8 * KB : 64 * KB; 55 56 // By default, do not GC until reaching 256KB. 57 static constexpr size_t kReservedCapacity = kInitialCapacity * 4; 58 59 // Create the code cache with a code + data capacity equal to "capacity", error message is passed 60 // in the out arg error_msg. 61 static JitCodeCache* Create(size_t initial_capacity, 62 size_t max_capacity, 63 bool generate_debug_info, 64 std::string* error_msg); 65 66 // Number of bytes allocated in the code cache. 67 size_t CodeCacheSize() REQUIRES(!lock_); 68 69 // Number of bytes allocated in the data cache. 70 size_t DataCacheSize() REQUIRES(!lock_); 71 72 bool NotifyCompilationOf(ArtMethod* method, Thread* self, bool osr) 73 SHARED_REQUIRES(Locks::mutator_lock_) 74 REQUIRES(!lock_); 75 76 // Notify to the code cache that the compiler wants to use the 77 // profiling info of `method` to drive optimizations, 78 // and therefore ensure the returned profiling info object is not 79 // collected. 80 ProfilingInfo* NotifyCompilerUse(ArtMethod* method, Thread* self) 81 SHARED_REQUIRES(Locks::mutator_lock_) 82 REQUIRES(!lock_); 83 84 void DoneCompiling(ArtMethod* method, Thread* self, bool osr) 85 SHARED_REQUIRES(Locks::mutator_lock_) 86 REQUIRES(!lock_); 87 88 void DoneCompilerUse(ArtMethod* method, Thread* self) 89 SHARED_REQUIRES(Locks::mutator_lock_) 90 REQUIRES(!lock_); 91 92 // Allocate and write code and its metadata to the code cache. 93 uint8_t* CommitCode(Thread* self, 94 ArtMethod* method, 95 const uint8_t* vmap_table, 96 size_t frame_size_in_bytes, 97 size_t core_spill_mask, 98 size_t fp_spill_mask, 99 const uint8_t* code, 100 size_t code_size, 101 bool osr) 102 SHARED_REQUIRES(Locks::mutator_lock_) 103 REQUIRES(!lock_); 104 105 // Return true if the code cache contains this pc. 106 bool ContainsPc(const void* pc) const; 107 108 // Return true if the code cache contains this method. 109 bool ContainsMethod(ArtMethod* method) REQUIRES(!lock_); 110 111 // Reserve a region of data of size at least "size". Returns null if there is no more room. 112 uint8_t* ReserveData(Thread* self, size_t size, ArtMethod* method) 113 SHARED_REQUIRES(Locks::mutator_lock_) 114 REQUIRES(!lock_); 115 116 // Clear data from the data portion of the code cache. 117 void ClearData(Thread* self, void* data) 118 SHARED_REQUIRES(Locks::mutator_lock_) 119 REQUIRES(!lock_); 120 121 CodeCacheBitmap* GetLiveBitmap() const { 122 return live_bitmap_.get(); 123 } 124 125 // Return whether we should do a full collection given the current state of the cache. 126 bool ShouldDoFullCollection() 127 REQUIRES(lock_) 128 SHARED_REQUIRES(Locks::mutator_lock_); 129 130 // Perform a collection on the code cache. 131 void GarbageCollectCache(Thread* self) 132 REQUIRES(!lock_) 133 SHARED_REQUIRES(Locks::mutator_lock_); 134 135 // Given the 'pc', try to find the JIT compiled code associated with it. 136 // Return null if 'pc' is not in the code cache. 'method' is passed for 137 // sanity check. 138 OatQuickMethodHeader* LookupMethodHeader(uintptr_t pc, ArtMethod* method) 139 REQUIRES(!lock_) 140 SHARED_REQUIRES(Locks::mutator_lock_); 141 142 OatQuickMethodHeader* LookupOsrMethodHeader(ArtMethod* method) 143 REQUIRES(!lock_) 144 SHARED_REQUIRES(Locks::mutator_lock_); 145 146 // Remove all methods in our cache that were allocated by 'alloc'. 147 void RemoveMethodsIn(Thread* self, const LinearAlloc& alloc) 148 REQUIRES(!lock_) 149 SHARED_REQUIRES(Locks::mutator_lock_); 150 151 void ClearGcRootsInInlineCaches(Thread* self) REQUIRES(!lock_); 152 153 // Create a 'ProfileInfo' for 'method'. If 'retry_allocation' is true, 154 // will collect and retry if the first allocation is unsuccessful. 155 ProfilingInfo* AddProfilingInfo(Thread* self, 156 ArtMethod* method, 157 const std::vector<uint32_t>& entries, 158 bool retry_allocation) 159 REQUIRES(!lock_) 160 SHARED_REQUIRES(Locks::mutator_lock_); 161 162 bool OwnsSpace(const void* mspace) const NO_THREAD_SAFETY_ANALYSIS { 163 return mspace == code_mspace_ || mspace == data_mspace_; 164 } 165 166 void* MoreCore(const void* mspace, intptr_t increment); 167 168 // Adds to `methods` all profiled methods which are part of any of the given dex locations. 169 void GetProfiledMethods(const std::set<std::string>& dex_base_locations, 170 std::vector<MethodReference>& methods) 171 REQUIRES(!lock_) 172 SHARED_REQUIRES(Locks::mutator_lock_); 173 174 uint64_t GetLastUpdateTimeNs() const; 175 176 size_t GetCurrentCapacity() REQUIRES(!lock_) { 177 MutexLock lock(Thread::Current(), lock_); 178 return current_capacity_; 179 } 180 181 size_t GetMemorySizeOfCodePointer(const void* ptr) REQUIRES(!lock_); 182 183 void InvalidateCompiledCodeFor(ArtMethod* method, const OatQuickMethodHeader* code) 184 REQUIRES(!lock_) 185 SHARED_REQUIRES(Locks::mutator_lock_); 186 187 void Dump(std::ostream& os) REQUIRES(!lock_); 188 189 bool IsOsrCompiled(ArtMethod* method) REQUIRES(!lock_); 190 191 private: 192 // Take ownership of maps. 193 JitCodeCache(MemMap* code_map, 194 MemMap* data_map, 195 size_t initial_code_capacity, 196 size_t initial_data_capacity, 197 size_t max_capacity, 198 bool garbage_collect_code); 199 200 // Internal version of 'CommitCode' that will not retry if the 201 // allocation fails. Return null if the allocation fails. 202 uint8_t* CommitCodeInternal(Thread* self, 203 ArtMethod* method, 204 const uint8_t* vmap_table, 205 size_t frame_size_in_bytes, 206 size_t core_spill_mask, 207 size_t fp_spill_mask, 208 const uint8_t* code, 209 size_t code_size, 210 bool osr) 211 REQUIRES(!lock_) 212 SHARED_REQUIRES(Locks::mutator_lock_); 213 214 ProfilingInfo* AddProfilingInfoInternal(Thread* self, 215 ArtMethod* method, 216 const std::vector<uint32_t>& entries) 217 REQUIRES(lock_) 218 SHARED_REQUIRES(Locks::mutator_lock_); 219 220 // If a collection is in progress, wait for it to finish. Return 221 // whether the thread actually waited. 222 bool WaitForPotentialCollectionToComplete(Thread* self) 223 REQUIRES(lock_) REQUIRES(!Locks::mutator_lock_); 224 225 // Free in the mspace allocations taken by 'method'. 226 void FreeCode(const void* code_ptr, ArtMethod* method) REQUIRES(lock_); 227 228 // Number of bytes allocated in the code cache. 229 size_t CodeCacheSizeLocked() REQUIRES(lock_); 230 231 // Number of bytes allocated in the data cache. 232 size_t DataCacheSizeLocked() REQUIRES(lock_); 233 234 // Notify all waiting threads that a collection is done. 235 void NotifyCollectionDone(Thread* self) REQUIRES(lock_); 236 237 // Try to increase the current capacity of the code cache. Return whether we 238 // succeeded at doing so. 239 bool IncreaseCodeCacheCapacity() REQUIRES(lock_); 240 241 // Set the footprint limit of the code cache. 242 void SetFootprintLimit(size_t new_footprint) REQUIRES(lock_); 243 244 void DoCollection(Thread* self, bool collect_profiling_info) 245 REQUIRES(!lock_) 246 SHARED_REQUIRES(Locks::mutator_lock_); 247 248 void RemoveUnmarkedCode(Thread* self) 249 REQUIRES(!lock_) 250 SHARED_REQUIRES(Locks::mutator_lock_); 251 252 void MarkCompiledCodeOnThreadStacks(Thread* self) 253 REQUIRES(!lock_) 254 SHARED_REQUIRES(Locks::mutator_lock_); 255 256 bool CheckLiveCompiledCodeHasProfilingInfo() 257 REQUIRES(lock_); 258 259 void FreeCode(uint8_t* code) REQUIRES(lock_); 260 uint8_t* AllocateCode(size_t code_size) REQUIRES(lock_); 261 void FreeData(uint8_t* data) REQUIRES(lock_); 262 uint8_t* AllocateData(size_t data_size) REQUIRES(lock_); 263 264 // Lock for guarding allocations, collections, and the method_code_map_. 265 Mutex lock_; 266 // Condition to wait on during collection. 267 ConditionVariable lock_cond_ GUARDED_BY(lock_); 268 // Whether there is a code cache collection in progress. 269 bool collection_in_progress_ GUARDED_BY(lock_); 270 // Mem map which holds code. 271 std::unique_ptr<MemMap> code_map_; 272 // Mem map which holds data (stack maps and profiling info). 273 std::unique_ptr<MemMap> data_map_; 274 // The opaque mspace for allocating code. 275 void* code_mspace_ GUARDED_BY(lock_); 276 // The opaque mspace for allocating data. 277 void* data_mspace_ GUARDED_BY(lock_); 278 // Bitmap for collecting code and data. 279 std::unique_ptr<CodeCacheBitmap> live_bitmap_; 280 // Holds compiled code associated to the ArtMethod. 281 SafeMap<const void*, ArtMethod*> method_code_map_ GUARDED_BY(lock_); 282 // Holds osr compiled code associated to the ArtMethod. 283 SafeMap<ArtMethod*, const void*> osr_code_map_ GUARDED_BY(lock_); 284 // ProfilingInfo objects we have allocated. 285 std::vector<ProfilingInfo*> profiling_infos_ GUARDED_BY(lock_); 286 287 // The maximum capacity in bytes this code cache can go to. 288 size_t max_capacity_ GUARDED_BY(lock_); 289 290 // The current capacity in bytes of the code cache. 291 size_t current_capacity_ GUARDED_BY(lock_); 292 293 // The current footprint in bytes of the code portion of the code cache. 294 size_t code_end_ GUARDED_BY(lock_); 295 296 // The current footprint in bytes of the data portion of the code cache. 297 size_t data_end_ GUARDED_BY(lock_); 298 299 // Whether the last collection round increased the code cache. 300 bool last_collection_increased_code_cache_ GUARDED_BY(lock_); 301 302 // Last time the the code_cache was updated. 303 // It is atomic to avoid locking when reading it. 304 Atomic<uint64_t> last_update_time_ns_; 305 306 // Whether we can do garbage collection. 307 const bool garbage_collect_code_; 308 309 // The size in bytes of used memory for the data portion of the code cache. 310 size_t used_memory_for_data_ GUARDED_BY(lock_); 311 312 // The size in bytes of used memory for the code portion of the code cache. 313 size_t used_memory_for_code_ GUARDED_BY(lock_); 314 315 // Number of compilations done throughout the lifetime of the JIT. 316 size_t number_of_compilations_ GUARDED_BY(lock_); 317 318 // Number of compilations for on-stack-replacement done throughout the lifetime of the JIT. 319 size_t number_of_osr_compilations_ GUARDED_BY(lock_); 320 321 // Number of deoptimizations done throughout the lifetime of the JIT. 322 size_t number_of_deoptimizations_ GUARDED_BY(lock_); 323 324 // Number of code cache collections done throughout the lifetime of the JIT. 325 size_t number_of_collections_ GUARDED_BY(lock_); 326 327 // Histograms for keeping track of stack map size statistics. 328 Histogram<uint64_t> histogram_stack_map_memory_use_ GUARDED_BY(lock_); 329 330 // Histograms for keeping track of code size statistics. 331 Histogram<uint64_t> histogram_code_memory_use_ GUARDED_BY(lock_); 332 333 // Histograms for keeping track of profiling info statistics. 334 Histogram<uint64_t> histogram_profiling_info_memory_use_ GUARDED_BY(lock_); 335 336 DISALLOW_IMPLICIT_CONSTRUCTORS(JitCodeCache); 337 }; 338 339 } // namespace jit 340 } // namespace art 341 342 #endif // ART_RUNTIME_JIT_JIT_CODE_CACHE_H_ 343
