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 REQUIRES(Locks::classlinker_classes_lock_) 150 SHARED_REQUIRES(Locks::mutator_lock_); 151 152 void ClearGcRootsInInlineCaches(Thread* self) REQUIRES(!lock_); 153 154 // Create a 'ProfileInfo' for 'method'. If 'retry_allocation' is true, 155 // will collect and retry if the first allocation is unsuccessful. 156 ProfilingInfo* AddProfilingInfo(Thread* self, 157 ArtMethod* method, 158 const std::vector<uint32_t>& entries, 159 bool retry_allocation) 160 REQUIRES(!lock_) 161 SHARED_REQUIRES(Locks::mutator_lock_); 162 163 bool OwnsSpace(const void* mspace) const NO_THREAD_SAFETY_ANALYSIS { 164 return mspace == code_mspace_ || mspace == data_mspace_; 165 } 166 167 void* MoreCore(const void* mspace, intptr_t increment); 168 169 // Adds to `methods` all profiled methods which are part of any of the given dex locations. 170 void GetProfiledMethods(const std::set<std::string>& dex_base_locations, 171 std::vector<MethodReference>& methods) 172 REQUIRES(!lock_) 173 SHARED_REQUIRES(Locks::mutator_lock_); 174 175 uint64_t GetLastUpdateTimeNs() const; 176 177 size_t GetCurrentCapacity() REQUIRES(!lock_) { 178 MutexLock lock(Thread::Current(), lock_); 179 return current_capacity_; 180 } 181 182 size_t GetMemorySizeOfCodePointer(const void* ptr) REQUIRES(!lock_); 183 184 void InvalidateCompiledCodeFor(ArtMethod* method, const OatQuickMethodHeader* code) 185 REQUIRES(!lock_) 186 SHARED_REQUIRES(Locks::mutator_lock_); 187 188 void Dump(std::ostream& os) REQUIRES(!lock_); 189 190 bool IsOsrCompiled(ArtMethod* method) REQUIRES(!lock_); 191 192 private: 193 // Take ownership of maps. 194 JitCodeCache(MemMap* code_map, 195 MemMap* data_map, 196 size_t initial_code_capacity, 197 size_t initial_data_capacity, 198 size_t max_capacity, 199 bool garbage_collect_code); 200 201 // Internal version of 'CommitCode' that will not retry if the 202 // allocation fails. Return null if the allocation fails. 203 uint8_t* CommitCodeInternal(Thread* self, 204 ArtMethod* method, 205 const uint8_t* vmap_table, 206 size_t frame_size_in_bytes, 207 size_t core_spill_mask, 208 size_t fp_spill_mask, 209 const uint8_t* code, 210 size_t code_size, 211 bool osr) 212 REQUIRES(!lock_) 213 SHARED_REQUIRES(Locks::mutator_lock_); 214 215 ProfilingInfo* AddProfilingInfoInternal(Thread* self, 216 ArtMethod* method, 217 const std::vector<uint32_t>& entries) 218 REQUIRES(lock_) 219 SHARED_REQUIRES(Locks::mutator_lock_); 220 221 // If a collection is in progress, wait for it to finish. Return 222 // whether the thread actually waited. 223 bool WaitForPotentialCollectionToComplete(Thread* self) 224 REQUIRES(lock_) REQUIRES(!Locks::mutator_lock_); 225 226 // Free in the mspace allocations taken by 'method'. 227 void FreeCode(const void* code_ptr, ArtMethod* method) REQUIRES(lock_); 228 229 // Number of bytes allocated in the code cache. 230 size_t CodeCacheSizeLocked() REQUIRES(lock_); 231 232 // Number of bytes allocated in the data cache. 233 size_t DataCacheSizeLocked() REQUIRES(lock_); 234 235 // Notify all waiting threads that a collection is done. 236 void NotifyCollectionDone(Thread* self) REQUIRES(lock_); 237 238 // Try to increase the current capacity of the code cache. Return whether we 239 // succeeded at doing so. 240 bool IncreaseCodeCacheCapacity() REQUIRES(lock_); 241 242 // Set the footprint limit of the code cache. 243 void SetFootprintLimit(size_t new_footprint) REQUIRES(lock_); 244 245 void DoCollection(Thread* self, bool collect_profiling_info) 246 REQUIRES(!lock_) 247 SHARED_REQUIRES(Locks::mutator_lock_); 248 249 void RemoveUnmarkedCode(Thread* self) 250 REQUIRES(!lock_) 251 SHARED_REQUIRES(Locks::mutator_lock_); 252 253 void MarkCompiledCodeOnThreadStacks(Thread* self) 254 REQUIRES(!lock_) 255 SHARED_REQUIRES(Locks::mutator_lock_); 256 257 bool CheckLiveCompiledCodeHasProfilingInfo() 258 REQUIRES(lock_) 259 SHARED_REQUIRES(Locks::mutator_lock_); 260 261 void FreeCode(uint8_t* code) REQUIRES(lock_); 262 uint8_t* AllocateCode(size_t code_size) REQUIRES(lock_); 263 void FreeData(uint8_t* data) REQUIRES(lock_); 264 uint8_t* AllocateData(size_t data_size) REQUIRES(lock_); 265 266 // Lock for guarding allocations, collections, and the method_code_map_. 267 Mutex lock_; 268 // Condition to wait on during collection. 269 ConditionVariable lock_cond_ GUARDED_BY(lock_); 270 // Whether there is a code cache collection in progress. 271 bool collection_in_progress_ GUARDED_BY(lock_); 272 // Mem map which holds code. 273 std::unique_ptr<MemMap> code_map_; 274 // Mem map which holds data (stack maps and profiling info). 275 std::unique_ptr<MemMap> data_map_; 276 // The opaque mspace for allocating code. 277 void* code_mspace_ GUARDED_BY(lock_); 278 // The opaque mspace for allocating data. 279 void* data_mspace_ GUARDED_BY(lock_); 280 // Bitmap for collecting code and data. 281 std::unique_ptr<CodeCacheBitmap> live_bitmap_; 282 // Holds compiled code associated to the ArtMethod. 283 SafeMap<const void*, ArtMethod*> method_code_map_ GUARDED_BY(lock_); 284 // Holds osr compiled code associated to the ArtMethod. 285 SafeMap<ArtMethod*, const void*> osr_code_map_ GUARDED_BY(lock_); 286 // ProfilingInfo objects we have allocated. 287 std::vector<ProfilingInfo*> profiling_infos_ GUARDED_BY(lock_); 288 289 // The maximum capacity in bytes this code cache can go to. 290 size_t max_capacity_ GUARDED_BY(lock_); 291 292 // The current capacity in bytes of the code cache. 293 size_t current_capacity_ GUARDED_BY(lock_); 294 295 // The current footprint in bytes of the code portion of the code cache. 296 size_t code_end_ GUARDED_BY(lock_); 297 298 // The current footprint in bytes of the data portion of the code cache. 299 size_t data_end_ GUARDED_BY(lock_); 300 301 // Whether the last collection round increased the code cache. 302 bool last_collection_increased_code_cache_ GUARDED_BY(lock_); 303 304 // Last time the the code_cache was updated. 305 // It is atomic to avoid locking when reading it. 306 Atomic<uint64_t> last_update_time_ns_; 307 308 // Whether we can do garbage collection. 309 const bool garbage_collect_code_; 310 311 // The size in bytes of used memory for the data portion of the code cache. 312 size_t used_memory_for_data_ GUARDED_BY(lock_); 313 314 // The size in bytes of used memory for the code portion of the code cache. 315 size_t used_memory_for_code_ GUARDED_BY(lock_); 316 317 // Number of compilations done throughout the lifetime of the JIT. 318 size_t number_of_compilations_ GUARDED_BY(lock_); 319 320 // Number of compilations for on-stack-replacement done throughout the lifetime of the JIT. 321 size_t number_of_osr_compilations_ GUARDED_BY(lock_); 322 323 // Number of deoptimizations done throughout the lifetime of the JIT. 324 size_t number_of_deoptimizations_ GUARDED_BY(lock_); 325 326 // Number of code cache collections done throughout the lifetime of the JIT. 327 size_t number_of_collections_ GUARDED_BY(lock_); 328 329 // Histograms for keeping track of stack map size statistics. 330 Histogram<uint64_t> histogram_stack_map_memory_use_ GUARDED_BY(lock_); 331 332 // Histograms for keeping track of code size statistics. 333 Histogram<uint64_t> histogram_code_memory_use_ GUARDED_BY(lock_); 334 335 // Histograms for keeping track of profiling info statistics. 336 Histogram<uint64_t> histogram_profiling_info_memory_use_ GUARDED_BY(lock_); 337 338 DISALLOW_IMPLICIT_CONSTRUCTORS(JitCodeCache); 339 }; 340 341 } // namespace jit 342 } // namespace art 343 344 #endif // ART_RUNTIME_JIT_JIT_CODE_CACHE_H_ 345
