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 #include "jit.h" 18 19 #include <dlfcn.h> 20 21 #include "art_method-inl.h" 22 #include "base/enums.h" 23 #include "base/logging.h" 24 #include "base/memory_tool.h" 25 #include "debugger.h" 26 #include "entrypoints/runtime_asm_entrypoints.h" 27 #include "interpreter/interpreter.h" 28 #include "java_vm_ext.h" 29 #include "jit_code_cache.h" 30 #include "oat_file_manager.h" 31 #include "oat_quick_method_header.h" 32 #include "profile_compilation_info.h" 33 #include "profile_saver.h" 34 #include "runtime.h" 35 #include "runtime_options.h" 36 #include "stack.h" 37 #include "stack_map.h" 38 #include "thread-inl.h" 39 #include "thread_list.h" 40 #include "utils.h" 41 42 namespace art { 43 namespace jit { 44 45 static constexpr bool kEnableOnStackReplacement = true; 46 // At what priority to schedule jit threads. 9 is the lowest foreground priority on device. 47 static constexpr int kJitPoolThreadPthreadPriority = 9; 48 49 // Different compilation threshold constants. These can be overridden on the command line. 50 static constexpr size_t kJitDefaultCompileThreshold = 10000; // Non-debug default. 51 static constexpr size_t kJitStressDefaultCompileThreshold = 100; // Fast-debug build. 52 static constexpr size_t kJitSlowStressDefaultCompileThreshold = 2; // Slow-debug build. 53 54 // JIT compiler 55 void* Jit::jit_library_handle_= nullptr; 56 void* Jit::jit_compiler_handle_ = nullptr; 57 void* (*Jit::jit_load_)(bool*) = nullptr; 58 void (*Jit::jit_unload_)(void*) = nullptr; 59 bool (*Jit::jit_compile_method_)(void*, ArtMethod*, Thread*, bool) = nullptr; 60 void (*Jit::jit_types_loaded_)(void*, mirror::Class**, size_t count) = nullptr; 61 bool Jit::generate_debug_info_ = false; 62 63 struct StressModeHelper { 64 DECLARE_RUNTIME_DEBUG_FLAG(kSlowMode); 65 }; 66 DEFINE_RUNTIME_DEBUG_FLAG(StressModeHelper, kSlowMode); 67 68 JitOptions* JitOptions::CreateFromRuntimeArguments(const RuntimeArgumentMap& options) { 69 auto* jit_options = new JitOptions; 70 jit_options->use_jit_compilation_ = options.GetOrDefault(RuntimeArgumentMap::UseJitCompilation); 71 72 jit_options->code_cache_initial_capacity_ = 73 options.GetOrDefault(RuntimeArgumentMap::JITCodeCacheInitialCapacity); 74 jit_options->code_cache_max_capacity_ = 75 options.GetOrDefault(RuntimeArgumentMap::JITCodeCacheMaxCapacity); 76 jit_options->dump_info_on_shutdown_ = 77 options.Exists(RuntimeArgumentMap::DumpJITInfoOnShutdown); 78 jit_options->profile_saver_options_ = 79 options.GetOrDefault(RuntimeArgumentMap::ProfileSaverOpts); 80 81 if (options.Exists(RuntimeArgumentMap::JITCompileThreshold)) { 82 jit_options->compile_threshold_ = *options.Get(RuntimeArgumentMap::JITCompileThreshold); 83 } else { 84 jit_options->compile_threshold_ = 85 kIsDebugBuild 86 ? (StressModeHelper::kSlowMode 87 ? kJitSlowStressDefaultCompileThreshold 88 : kJitStressDefaultCompileThreshold) 89 : kJitDefaultCompileThreshold; 90 } 91 if (jit_options->compile_threshold_ > std::numeric_limits<uint16_t>::max()) { 92 LOG(FATAL) << "Method compilation threshold is above its internal limit."; 93 } 94 95 if (options.Exists(RuntimeArgumentMap::JITWarmupThreshold)) { 96 jit_options->warmup_threshold_ = *options.Get(RuntimeArgumentMap::JITWarmupThreshold); 97 if (jit_options->warmup_threshold_ > std::numeric_limits<uint16_t>::max()) { 98 LOG(FATAL) << "Method warmup threshold is above its internal limit."; 99 } 100 } else { 101 jit_options->warmup_threshold_ = jit_options->compile_threshold_ / 2; 102 } 103 104 if (options.Exists(RuntimeArgumentMap::JITOsrThreshold)) { 105 jit_options->osr_threshold_ = *options.Get(RuntimeArgumentMap::JITOsrThreshold); 106 if (jit_options->osr_threshold_ > std::numeric_limits<uint16_t>::max()) { 107 LOG(FATAL) << "Method on stack replacement threshold is above its internal limit."; 108 } 109 } else { 110 jit_options->osr_threshold_ = jit_options->compile_threshold_ * 2; 111 if (jit_options->osr_threshold_ > std::numeric_limits<uint16_t>::max()) { 112 jit_options->osr_threshold_ = std::numeric_limits<uint16_t>::max(); 113 } 114 } 115 116 if (options.Exists(RuntimeArgumentMap::JITPriorityThreadWeight)) { 117 jit_options->priority_thread_weight_ = 118 *options.Get(RuntimeArgumentMap::JITPriorityThreadWeight); 119 if (jit_options->priority_thread_weight_ > jit_options->warmup_threshold_) { 120 LOG(FATAL) << "Priority thread weight is above the warmup threshold."; 121 } else if (jit_options->priority_thread_weight_ == 0) { 122 LOG(FATAL) << "Priority thread weight cannot be 0."; 123 } 124 } else { 125 jit_options->priority_thread_weight_ = std::max( 126 jit_options->warmup_threshold_ / Jit::kDefaultPriorityThreadWeightRatio, 127 static_cast<size_t>(1)); 128 } 129 130 if (options.Exists(RuntimeArgumentMap::JITInvokeTransitionWeight)) { 131 jit_options->invoke_transition_weight_ = 132 *options.Get(RuntimeArgumentMap::JITInvokeTransitionWeight); 133 if (jit_options->invoke_transition_weight_ > jit_options->warmup_threshold_) { 134 LOG(FATAL) << "Invoke transition weight is above the warmup threshold."; 135 } else if (jit_options->invoke_transition_weight_ == 0) { 136 LOG(FATAL) << "Invoke transition weight cannot be 0."; 137 } 138 } else { 139 jit_options->invoke_transition_weight_ = std::max( 140 jit_options->warmup_threshold_ / Jit::kDefaultInvokeTransitionWeightRatio, 141 static_cast<size_t>(1)); 142 } 143 144 return jit_options; 145 } 146 147 bool Jit::ShouldUsePriorityThreadWeight() { 148 return Runtime::Current()->InJankPerceptibleProcessState() 149 && Thread::Current()->IsJitSensitiveThread(); 150 } 151 152 void Jit::DumpInfo(std::ostream& os) { 153 code_cache_->Dump(os); 154 cumulative_timings_.Dump(os); 155 MutexLock mu(Thread::Current(), lock_); 156 memory_use_.PrintMemoryUse(os); 157 } 158 159 void Jit::DumpForSigQuit(std::ostream& os) { 160 DumpInfo(os); 161 ProfileSaver::DumpInstanceInfo(os); 162 } 163 164 void Jit::AddTimingLogger(const TimingLogger& logger) { 165 cumulative_timings_.AddLogger(logger); 166 } 167 168 Jit::Jit() : dump_info_on_shutdown_(false), 169 cumulative_timings_("JIT timings"), 170 memory_use_("Memory used for compilation", 16), 171 lock_("JIT memory use lock"), 172 use_jit_compilation_(true), 173 hot_method_threshold_(0), 174 warm_method_threshold_(0), 175 osr_method_threshold_(0), 176 priority_thread_weight_(0), 177 invoke_transition_weight_(0) {} 178 179 Jit* Jit::Create(JitOptions* options, std::string* error_msg) { 180 DCHECK(options->UseJitCompilation() || options->GetProfileSaverOptions().IsEnabled()); 181 std::unique_ptr<Jit> jit(new Jit); 182 jit->dump_info_on_shutdown_ = options->DumpJitInfoOnShutdown(); 183 if (jit_compiler_handle_ == nullptr && !LoadCompiler(error_msg)) { 184 return nullptr; 185 } 186 jit->code_cache_.reset(JitCodeCache::Create( 187 options->GetCodeCacheInitialCapacity(), 188 options->GetCodeCacheMaxCapacity(), 189 jit->generate_debug_info_, 190 error_msg)); 191 if (jit->GetCodeCache() == nullptr) { 192 return nullptr; 193 } 194 jit->use_jit_compilation_ = options->UseJitCompilation(); 195 jit->profile_saver_options_ = options->GetProfileSaverOptions(); 196 VLOG(jit) << "JIT created with initial_capacity=" 197 << PrettySize(options->GetCodeCacheInitialCapacity()) 198 << ", max_capacity=" << PrettySize(options->GetCodeCacheMaxCapacity()) 199 << ", compile_threshold=" << options->GetCompileThreshold() 200 << ", profile_saver_options=" << options->GetProfileSaverOptions(); 201 202 203 jit->hot_method_threshold_ = options->GetCompileThreshold(); 204 jit->warm_method_threshold_ = options->GetWarmupThreshold(); 205 jit->osr_method_threshold_ = options->GetOsrThreshold(); 206 jit->priority_thread_weight_ = options->GetPriorityThreadWeight(); 207 jit->invoke_transition_weight_ = options->GetInvokeTransitionWeight(); 208 209 jit->CreateThreadPool(); 210 211 // Notify native debugger about the classes already loaded before the creation of the jit. 212 jit->DumpTypeInfoForLoadedTypes(Runtime::Current()->GetClassLinker()); 213 return jit.release(); 214 } 215 216 bool Jit::LoadCompilerLibrary(std::string* error_msg) { 217 jit_library_handle_ = dlopen( 218 kIsDebugBuild ? "libartd-compiler.so" : "libart-compiler.so", RTLD_NOW); 219 if (jit_library_handle_ == nullptr) { 220 std::ostringstream oss; 221 oss << "JIT could not load libart-compiler.so: " << dlerror(); 222 *error_msg = oss.str(); 223 return false; 224 } 225 jit_load_ = reinterpret_cast<void* (*)(bool*)>(dlsym(jit_library_handle_, "jit_load")); 226 if (jit_load_ == nullptr) { 227 dlclose(jit_library_handle_); 228 *error_msg = "JIT couldn't find jit_load entry point"; 229 return false; 230 } 231 jit_unload_ = reinterpret_cast<void (*)(void*)>( 232 dlsym(jit_library_handle_, "jit_unload")); 233 if (jit_unload_ == nullptr) { 234 dlclose(jit_library_handle_); 235 *error_msg = "JIT couldn't find jit_unload entry point"; 236 return false; 237 } 238 jit_compile_method_ = reinterpret_cast<bool (*)(void*, ArtMethod*, Thread*, bool)>( 239 dlsym(jit_library_handle_, "jit_compile_method")); 240 if (jit_compile_method_ == nullptr) { 241 dlclose(jit_library_handle_); 242 *error_msg = "JIT couldn't find jit_compile_method entry point"; 243 return false; 244 } 245 jit_types_loaded_ = reinterpret_cast<void (*)(void*, mirror::Class**, size_t)>( 246 dlsym(jit_library_handle_, "jit_types_loaded")); 247 if (jit_types_loaded_ == nullptr) { 248 dlclose(jit_library_handle_); 249 *error_msg = "JIT couldn't find jit_types_loaded entry point"; 250 return false; 251 } 252 return true; 253 } 254 255 bool Jit::LoadCompiler(std::string* error_msg) { 256 if (jit_library_handle_ == nullptr && !LoadCompilerLibrary(error_msg)) { 257 return false; 258 } 259 bool will_generate_debug_symbols = false; 260 VLOG(jit) << "Calling JitLoad interpreter_only=" 261 << Runtime::Current()->GetInstrumentation()->InterpretOnly(); 262 jit_compiler_handle_ = (jit_load_)(&will_generate_debug_symbols); 263 if (jit_compiler_handle_ == nullptr) { 264 dlclose(jit_library_handle_); 265 *error_msg = "JIT couldn't load compiler"; 266 return false; 267 } 268 generate_debug_info_ = will_generate_debug_symbols; 269 return true; 270 } 271 272 bool Jit::CompileMethod(ArtMethod* method, Thread* self, bool osr) { 273 DCHECK(Runtime::Current()->UseJitCompilation()); 274 DCHECK(!method->IsRuntimeMethod()); 275 276 // Don't compile the method if it has breakpoints. 277 if (Dbg::IsDebuggerActive() && Dbg::MethodHasAnyBreakpoints(method)) { 278 VLOG(jit) << "JIT not compiling " << method->PrettyMethod() << " due to breakpoint"; 279 return false; 280 } 281 282 // Don't compile the method if we are supposed to be deoptimized. 283 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation(); 284 if (instrumentation->AreAllMethodsDeoptimized() || instrumentation->IsDeoptimized(method)) { 285 VLOG(jit) << "JIT not compiling " << method->PrettyMethod() << " due to deoptimization"; 286 return false; 287 } 288 289 // If we get a request to compile a proxy method, we pass the actual Java method 290 // of that proxy method, as the compiler does not expect a proxy method. 291 ArtMethod* method_to_compile = method->GetInterfaceMethodIfProxy(kRuntimePointerSize); 292 if (!code_cache_->NotifyCompilationOf(method_to_compile, self, osr)) { 293 return false; 294 } 295 296 VLOG(jit) << "Compiling method " 297 << ArtMethod::PrettyMethod(method_to_compile) 298 << " osr=" << std::boolalpha << osr; 299 bool success = jit_compile_method_(jit_compiler_handle_, method_to_compile, self, osr); 300 code_cache_->DoneCompiling(method_to_compile, self, osr); 301 if (!success) { 302 VLOG(jit) << "Failed to compile method " 303 << ArtMethod::PrettyMethod(method_to_compile) 304 << " osr=" << std::boolalpha << osr; 305 } 306 if (kIsDebugBuild) { 307 if (self->IsExceptionPending()) { 308 mirror::Throwable* exception = self->GetException(); 309 LOG(FATAL) << "No pending exception expected after compiling " 310 << ArtMethod::PrettyMethod(method) 311 << ": " 312 << exception->Dump(); 313 } 314 } 315 return success; 316 } 317 318 void Jit::CreateThreadPool() { 319 // There is a DCHECK in the 'AddSamples' method to ensure the tread pool 320 // is not null when we instrument. 321 322 // We need peers as we may report the JIT thread, e.g., in the debugger. 323 constexpr bool kJitPoolNeedsPeers = true; 324 thread_pool_.reset(new ThreadPool("Jit thread pool", 1, kJitPoolNeedsPeers)); 325 326 thread_pool_->SetPthreadPriority(kJitPoolThreadPthreadPriority); 327 Start(); 328 } 329 330 void Jit::DeleteThreadPool() { 331 Thread* self = Thread::Current(); 332 DCHECK(Runtime::Current()->IsShuttingDown(self)); 333 if (thread_pool_ != nullptr) { 334 std::unique_ptr<ThreadPool> pool; 335 { 336 ScopedSuspendAll ssa(__FUNCTION__); 337 // Clear thread_pool_ field while the threads are suspended. 338 // A mutator in the 'AddSamples' method will check against it. 339 pool = std::move(thread_pool_); 340 } 341 342 // When running sanitized, let all tasks finish to not leak. Otherwise just clear the queue. 343 if (!RUNNING_ON_MEMORY_TOOL) { 344 pool->StopWorkers(self); 345 pool->RemoveAllTasks(self); 346 } 347 // We could just suspend all threads, but we know those threads 348 // will finish in a short period, so it's not worth adding a suspend logic 349 // here. Besides, this is only done for shutdown. 350 pool->Wait(self, false, false); 351 } 352 } 353 354 void Jit::StartProfileSaver(const std::string& filename, 355 const std::vector<std::string>& code_paths) { 356 if (profile_saver_options_.IsEnabled()) { 357 ProfileSaver::Start(profile_saver_options_, 358 filename, 359 code_cache_.get(), 360 code_paths); 361 } 362 } 363 364 void Jit::StopProfileSaver() { 365 if (profile_saver_options_.IsEnabled() && ProfileSaver::IsStarted()) { 366 ProfileSaver::Stop(dump_info_on_shutdown_); 367 } 368 } 369 370 bool Jit::JitAtFirstUse() { 371 return HotMethodThreshold() == 0; 372 } 373 374 bool Jit::CanInvokeCompiledCode(ArtMethod* method) { 375 return code_cache_->ContainsPc(method->GetEntryPointFromQuickCompiledCode()); 376 } 377 378 Jit::~Jit() { 379 DCHECK(!profile_saver_options_.IsEnabled() || !ProfileSaver::IsStarted()); 380 if (dump_info_on_shutdown_) { 381 DumpInfo(LOG_STREAM(INFO)); 382 Runtime::Current()->DumpDeoptimizations(LOG_STREAM(INFO)); 383 } 384 DeleteThreadPool(); 385 if (jit_compiler_handle_ != nullptr) { 386 jit_unload_(jit_compiler_handle_); 387 jit_compiler_handle_ = nullptr; 388 } 389 if (jit_library_handle_ != nullptr) { 390 dlclose(jit_library_handle_); 391 jit_library_handle_ = nullptr; 392 } 393 } 394 395 void Jit::NewTypeLoadedIfUsingJit(mirror::Class* type) { 396 if (!Runtime::Current()->UseJitCompilation()) { 397 // No need to notify if we only use the JIT to save profiles. 398 return; 399 } 400 jit::Jit* jit = Runtime::Current()->GetJit(); 401 if (jit->generate_debug_info_) { 402 DCHECK(jit->jit_types_loaded_ != nullptr); 403 jit->jit_types_loaded_(jit->jit_compiler_handle_, &type, 1); 404 } 405 } 406 407 void Jit::DumpTypeInfoForLoadedTypes(ClassLinker* linker) { 408 struct CollectClasses : public ClassVisitor { 409 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { 410 classes_.push_back(klass.Ptr()); 411 return true; 412 } 413 std::vector<mirror::Class*> classes_; 414 }; 415 416 if (generate_debug_info_) { 417 ScopedObjectAccess so(Thread::Current()); 418 419 CollectClasses visitor; 420 linker->VisitClasses(&visitor); 421 jit_types_loaded_(jit_compiler_handle_, visitor.classes_.data(), visitor.classes_.size()); 422 } 423 } 424 425 extern "C" void art_quick_osr_stub(void** stack, 426 uint32_t stack_size_in_bytes, 427 const uint8_t* native_pc, 428 JValue* result, 429 const char* shorty, 430 Thread* self); 431 432 bool Jit::MaybeDoOnStackReplacement(Thread* thread, 433 ArtMethod* method, 434 uint32_t dex_pc, 435 int32_t dex_pc_offset, 436 JValue* result) { 437 if (!kEnableOnStackReplacement) { 438 return false; 439 } 440 441 Jit* jit = Runtime::Current()->GetJit(); 442 if (jit == nullptr) { 443 return false; 444 } 445 446 if (UNLIKELY(__builtin_frame_address(0) < thread->GetStackEnd())) { 447 // Don't attempt to do an OSR if we are close to the stack limit. Since 448 // the interpreter frames are still on stack, OSR has the potential 449 // to stack overflow even for a simple loop. 450 // b/27094810. 451 return false; 452 } 453 454 // Get the actual Java method if this method is from a proxy class. The compiler 455 // and the JIT code cache do not expect methods from proxy classes. 456 method = method->GetInterfaceMethodIfProxy(kRuntimePointerSize); 457 458 // Cheap check if the method has been compiled already. That's an indicator that we should 459 // osr into it. 460 if (!jit->GetCodeCache()->ContainsPc(method->GetEntryPointFromQuickCompiledCode())) { 461 return false; 462 } 463 464 // Fetch some data before looking up for an OSR method. We don't want thread 465 // suspension once we hold an OSR method, as the JIT code cache could delete the OSR 466 // method while we are being suspended. 467 const size_t number_of_vregs = method->GetCodeItem()->registers_size_; 468 const char* shorty = method->GetShorty(); 469 std::string method_name(VLOG_IS_ON(jit) ? method->PrettyMethod() : ""); 470 void** memory = nullptr; 471 size_t frame_size = 0; 472 ShadowFrame* shadow_frame = nullptr; 473 const uint8_t* native_pc = nullptr; 474 475 { 476 ScopedAssertNoThreadSuspension sts("Holding OSR method"); 477 const OatQuickMethodHeader* osr_method = jit->GetCodeCache()->LookupOsrMethodHeader(method); 478 if (osr_method == nullptr) { 479 // No osr method yet, just return to the interpreter. 480 return false; 481 } 482 483 CodeInfo code_info = osr_method->GetOptimizedCodeInfo(); 484 CodeInfoEncoding encoding = code_info.ExtractEncoding(); 485 486 // Find stack map starting at the target dex_pc. 487 StackMap stack_map = code_info.GetOsrStackMapForDexPc(dex_pc + dex_pc_offset, encoding); 488 if (!stack_map.IsValid()) { 489 // There is no OSR stack map for this dex pc offset. Just return to the interpreter in the 490 // hope that the next branch has one. 491 return false; 492 } 493 494 // Before allowing the jump, make sure the debugger is not active to avoid jumping from 495 // interpreter to OSR while e.g. single stepping. Note that we could selectively disable 496 // OSR when single stepping, but that's currently hard to know at this point. 497 if (Dbg::IsDebuggerActive()) { 498 return false; 499 } 500 501 // We found a stack map, now fill the frame with dex register values from the interpreter's 502 // shadow frame. 503 DexRegisterMap vreg_map = 504 code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_vregs); 505 506 frame_size = osr_method->GetFrameSizeInBytes(); 507 508 // Allocate memory to put shadow frame values. The osr stub will copy that memory to 509 // stack. 510 // Note that we could pass the shadow frame to the stub, and let it copy the values there, 511 // but that is engineering complexity not worth the effort for something like OSR. 512 memory = reinterpret_cast<void**>(malloc(frame_size)); 513 CHECK(memory != nullptr); 514 memset(memory, 0, frame_size); 515 516 // Art ABI: ArtMethod is at the bottom of the stack. 517 memory[0] = method; 518 519 shadow_frame = thread->PopShadowFrame(); 520 if (!vreg_map.IsValid()) { 521 // If we don't have a dex register map, then there are no live dex registers at 522 // this dex pc. 523 } else { 524 for (uint16_t vreg = 0; vreg < number_of_vregs; ++vreg) { 525 DexRegisterLocation::Kind location = 526 vreg_map.GetLocationKind(vreg, number_of_vregs, code_info, encoding); 527 if (location == DexRegisterLocation::Kind::kNone) { 528 // Dex register is dead or uninitialized. 529 continue; 530 } 531 532 if (location == DexRegisterLocation::Kind::kConstant) { 533 // We skip constants because the compiled code knows how to handle them. 534 continue; 535 } 536 537 DCHECK_EQ(location, DexRegisterLocation::Kind::kInStack); 538 539 int32_t vreg_value = shadow_frame->GetVReg(vreg); 540 int32_t slot_offset = vreg_map.GetStackOffsetInBytes(vreg, 541 number_of_vregs, 542 code_info, 543 encoding); 544 DCHECK_LT(slot_offset, static_cast<int32_t>(frame_size)); 545 DCHECK_GT(slot_offset, 0); 546 (reinterpret_cast<int32_t*>(memory))[slot_offset / sizeof(int32_t)] = vreg_value; 547 } 548 } 549 550 native_pc = stack_map.GetNativePcOffset(encoding.stack_map.encoding, kRuntimeISA) + 551 osr_method->GetEntryPoint(); 552 VLOG(jit) << "Jumping to " 553 << method_name 554 << "@" 555 << std::hex << reinterpret_cast<uintptr_t>(native_pc); 556 } 557 558 { 559 ManagedStack fragment; 560 thread->PushManagedStackFragment(&fragment); 561 (*art_quick_osr_stub)(memory, 562 frame_size, 563 native_pc, 564 result, 565 shorty, 566 thread); 567 568 if (UNLIKELY(thread->GetException() == Thread::GetDeoptimizationException())) { 569 thread->DeoptimizeWithDeoptimizationException(result); 570 } 571 thread->PopManagedStackFragment(fragment); 572 } 573 free(memory); 574 thread->PushShadowFrame(shadow_frame); 575 VLOG(jit) << "Done running OSR code for " << method_name; 576 return true; 577 } 578 579 void Jit::AddMemoryUsage(ArtMethod* method, size_t bytes) { 580 if (bytes > 4 * MB) { 581 LOG(INFO) << "Compiler allocated " 582 << PrettySize(bytes) 583 << " to compile " 584 << ArtMethod::PrettyMethod(method); 585 } 586 MutexLock mu(Thread::Current(), lock_); 587 memory_use_.AddValue(bytes); 588 } 589 590 class JitCompileTask FINAL : public Task { 591 public: 592 enum TaskKind { 593 kAllocateProfile, 594 kCompile, 595 kCompileOsr 596 }; 597 598 JitCompileTask(ArtMethod* method, TaskKind kind) : method_(method), kind_(kind) { 599 ScopedObjectAccess soa(Thread::Current()); 600 // Add a global ref to the class to prevent class unloading until compilation is done. 601 klass_ = soa.Vm()->AddGlobalRef(soa.Self(), method_->GetDeclaringClass()); 602 CHECK(klass_ != nullptr); 603 } 604 605 ~JitCompileTask() { 606 ScopedObjectAccess soa(Thread::Current()); 607 soa.Vm()->DeleteGlobalRef(soa.Self(), klass_); 608 } 609 610 void Run(Thread* self) OVERRIDE { 611 ScopedObjectAccess soa(self); 612 if (kind_ == kCompile) { 613 Runtime::Current()->GetJit()->CompileMethod(method_, self, /* osr */ false); 614 } else if (kind_ == kCompileOsr) { 615 Runtime::Current()->GetJit()->CompileMethod(method_, self, /* osr */ true); 616 } else { 617 DCHECK(kind_ == kAllocateProfile); 618 if (ProfilingInfo::Create(self, method_, /* retry_allocation */ true)) { 619 VLOG(jit) << "Start profiling " << ArtMethod::PrettyMethod(method_); 620 } 621 } 622 ProfileSaver::NotifyJitActivity(); 623 } 624 625 void Finalize() OVERRIDE { 626 delete this; 627 } 628 629 private: 630 ArtMethod* const method_; 631 const TaskKind kind_; 632 jobject klass_; 633 634 DISALLOW_IMPLICIT_CONSTRUCTORS(JitCompileTask); 635 }; 636 637 void Jit::AddSamples(Thread* self, ArtMethod* method, uint16_t count, bool with_backedges) { 638 if (thread_pool_ == nullptr) { 639 // Should only see this when shutting down. 640 DCHECK(Runtime::Current()->IsShuttingDown(self)); 641 return; 642 } 643 644 if (method->IsClassInitializer() || method->IsNative() || !method->IsCompilable()) { 645 // We do not want to compile such methods. 646 return; 647 } 648 DCHECK(thread_pool_ != nullptr); 649 DCHECK_GT(warm_method_threshold_, 0); 650 DCHECK_GT(hot_method_threshold_, warm_method_threshold_); 651 DCHECK_GT(osr_method_threshold_, hot_method_threshold_); 652 DCHECK_GE(priority_thread_weight_, 1); 653 DCHECK_LE(priority_thread_weight_, hot_method_threshold_); 654 655 int32_t starting_count = method->GetCounter(); 656 if (Jit::ShouldUsePriorityThreadWeight()) { 657 count *= priority_thread_weight_; 658 } 659 int32_t new_count = starting_count + count; // int32 here to avoid wrap-around; 660 if (starting_count < warm_method_threshold_) { 661 if ((new_count >= warm_method_threshold_) && 662 (method->GetProfilingInfo(kRuntimePointerSize) == nullptr)) { 663 bool success = ProfilingInfo::Create(self, method, /* retry_allocation */ false); 664 if (success) { 665 VLOG(jit) << "Start profiling " << method->PrettyMethod(); 666 } 667 668 if (thread_pool_ == nullptr) { 669 // Calling ProfilingInfo::Create might put us in a suspended state, which could 670 // lead to the thread pool being deleted when we are shutting down. 671 DCHECK(Runtime::Current()->IsShuttingDown(self)); 672 return; 673 } 674 675 if (!success) { 676 // We failed allocating. Instead of doing the collection on the Java thread, we push 677 // an allocation to a compiler thread, that will do the collection. 678 thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kAllocateProfile)); 679 } 680 } 681 // Avoid jumping more than one state at a time. 682 new_count = std::min(new_count, hot_method_threshold_ - 1); 683 } else if (use_jit_compilation_) { 684 if (starting_count < hot_method_threshold_) { 685 if ((new_count >= hot_method_threshold_) && 686 !code_cache_->ContainsPc(method->GetEntryPointFromQuickCompiledCode())) { 687 DCHECK(thread_pool_ != nullptr); 688 thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kCompile)); 689 } 690 // Avoid jumping more than one state at a time. 691 new_count = std::min(new_count, osr_method_threshold_ - 1); 692 } else if (starting_count < osr_method_threshold_) { 693 if (!with_backedges) { 694 // If the samples don't contain any back edge, we don't increment the hotness. 695 return; 696 } 697 if ((new_count >= osr_method_threshold_) && !code_cache_->IsOsrCompiled(method)) { 698 DCHECK(thread_pool_ != nullptr); 699 thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kCompileOsr)); 700 } 701 } 702 } 703 // Update hotness counter 704 method->SetCounter(new_count); 705 } 706 707 void Jit::MethodEntered(Thread* thread, ArtMethod* method) { 708 Runtime* runtime = Runtime::Current(); 709 if (UNLIKELY(runtime->UseJitCompilation() && runtime->GetJit()->JitAtFirstUse())) { 710 // The compiler requires a ProfilingInfo object. 711 ProfilingInfo::Create(thread, method, /* retry_allocation */ true); 712 JitCompileTask compile_task(method, JitCompileTask::kCompile); 713 compile_task.Run(thread); 714 return; 715 } 716 717 ProfilingInfo* profiling_info = method->GetProfilingInfo(kRuntimePointerSize); 718 // Update the entrypoint if the ProfilingInfo has one. The interpreter will call it 719 // instead of interpreting the method. 720 if ((profiling_info != nullptr) && (profiling_info->GetSavedEntryPoint() != nullptr)) { 721 Runtime::Current()->GetInstrumentation()->UpdateMethodsCode( 722 method, profiling_info->GetSavedEntryPoint()); 723 } else { 724 AddSamples(thread, method, 1, /* with_backedges */false); 725 } 726 } 727 728 void Jit::InvokeVirtualOrInterface(ObjPtr<mirror::Object> this_object, 729 ArtMethod* caller, 730 uint32_t dex_pc, 731 ArtMethod* callee ATTRIBUTE_UNUSED) { 732 ScopedAssertNoThreadSuspension ants(__FUNCTION__); 733 DCHECK(this_object != nullptr); 734 ProfilingInfo* info = caller->GetProfilingInfo(kRuntimePointerSize); 735 if (info != nullptr) { 736 info->AddInvokeInfo(dex_pc, this_object->GetClass()); 737 } 738 } 739 740 void Jit::WaitForCompilationToFinish(Thread* self) { 741 if (thread_pool_ != nullptr) { 742 thread_pool_->Wait(self, false, false); 743 } 744 } 745 746 void Jit::Stop() { 747 Thread* self = Thread::Current(); 748 // TODO(ngeoffray): change API to not require calling WaitForCompilationToFinish twice. 749 WaitForCompilationToFinish(self); 750 GetThreadPool()->StopWorkers(self); 751 WaitForCompilationToFinish(self); 752 } 753 754 void Jit::Start() { 755 GetThreadPool()->StartWorkers(Thread::Current()); 756 } 757 758 ScopedJitSuspend::ScopedJitSuspend() { 759 jit::Jit* jit = Runtime::Current()->GetJit(); 760 was_on_ = (jit != nullptr) && (jit->GetThreadPool() != nullptr); 761 if (was_on_) { 762 jit->Stop(); 763 } 764 } 765 766 ScopedJitSuspend::~ScopedJitSuspend() { 767 if (was_on_) { 768 DCHECK(Runtime::Current()->GetJit() != nullptr); 769 DCHECK(Runtime::Current()->GetJit()->GetThreadPool() != nullptr); 770 Runtime::Current()->GetJit()->Start(); 771 } 772 } 773 774 } // namespace jit 775 } // namespace art 776