Add weight to compiled/interpreter transitions.
Also:
- Cleanup logging.
- Check ArtMethod status before adding compilation requests.
- Don't request osr compilation if we know AddSamples does not come
from a back edge.
Bug: 27865109
Change-Id: I84512f7d957b61ce2458360ed430adb151830278
diff --git a/runtime/jit/jit.cc b/runtime/jit/jit.cc
index 558e443..0a6da2c 100644
--- a/runtime/jit/jit.cc
+++ b/runtime/jit/jit.cc
@@ -97,8 +97,9 @@
LOG(FATAL) << "Priority thread weight cannot be 0.";
}
} else {
- jit_options->priority_thread_weight_ =
- std::max(jit_options->compile_threshold_ / 2000, static_cast<size_t>(1));
+ jit_options->priority_thread_weight_ = std::max(
+ jit_options->warmup_threshold_ / Jit::kDefaultPriorityThreadWeightRatio,
+ static_cast<size_t>(1));
}
return jit_options;
@@ -154,6 +155,8 @@
jit->warm_method_threshold_ = options->GetWarmupThreshold();
jit->osr_method_threshold_ = options->GetOsrThreshold();
jit->priority_thread_weight_ = options->GetPriorityThreadWeight();
+ jit->transition_weight_ = std::max(
+ jit->warm_method_threshold_ / kDefaultTransitionRatio, static_cast<size_t>(1));
jit->CreateThreadPool();
@@ -240,8 +243,17 @@
if (!code_cache_->NotifyCompilationOf(method_to_compile, self, osr)) {
return false;
}
+
+ VLOG(jit) << "Compiling method "
+ << PrettyMethod(method_to_compile)
+ << " osr=" << std::boolalpha << osr;
bool success = jit_compile_method_(jit_compiler_handle_, method_to_compile, self, osr);
code_cache_->DoneCompiling(method_to_compile, self, osr);
+ if (!success) {
+ VLOG(jit) << "Failed to compile method "
+ << PrettyMethod(method_to_compile)
+ << " osr=" << std::boolalpha << osr;
+ }
return success;
}
@@ -520,15 +532,9 @@
void Run(Thread* self) OVERRIDE {
ScopedObjectAccess soa(self);
if (kind_ == kCompile) {
- VLOG(jit) << "JitCompileTask compiling method " << PrettyMethod(method_);
- if (!Runtime::Current()->GetJit()->CompileMethod(method_, self, /* osr */ false)) {
- VLOG(jit) << "Failed to compile method " << PrettyMethod(method_);
- }
+ Runtime::Current()->GetJit()->CompileMethod(method_, self, /* osr */ false);
} else if (kind_ == kCompileOsr) {
- VLOG(jit) << "JitCompileTask compiling method osr " << PrettyMethod(method_);
- if (!Runtime::Current()->GetJit()->CompileMethod(method_, self, /* osr */ true)) {
- VLOG(jit) << "Failed to compile method osr " << PrettyMethod(method_);
- }
+ Runtime::Current()->GetJit()->CompileMethod(method_, self, /* osr */ true);
} else {
DCHECK(kind_ == kAllocateProfile);
if (ProfilingInfo::Create(self, method_, /* retry_allocation */ true)) {
@@ -549,7 +555,7 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(JitCompileTask);
};
-void Jit::AddSamples(Thread* self, ArtMethod* method, uint16_t count) {
+void Jit::AddSamples(Thread* self, ArtMethod* method, uint16_t count, bool with_backedges) {
if (thread_pool_ == nullptr) {
// Should only see this when shutting down.
DCHECK(Runtime::Current()->IsShuttingDown(self));
@@ -573,7 +579,8 @@
}
int32_t new_count = starting_count + count; // int32 here to avoid wrap-around;
if (starting_count < warm_method_threshold_) {
- if (new_count >= warm_method_threshold_) {
+ if ((new_count >= warm_method_threshold_) &&
+ (method->GetProfilingInfo(sizeof(void*)) == nullptr)) {
bool success = ProfilingInfo::Create(self, method, /* retry_allocation */ false);
if (success) {
VLOG(jit) << "Start profiling " << PrettyMethod(method);
@@ -595,14 +602,19 @@
// Avoid jumping more than one state at a time.
new_count = std::min(new_count, hot_method_threshold_ - 1);
} else if (starting_count < hot_method_threshold_) {
- if (new_count >= hot_method_threshold_) {
+ if ((new_count >= hot_method_threshold_) &&
+ !code_cache_->ContainsPc(method->GetEntryPointFromQuickCompiledCode())) {
DCHECK(thread_pool_ != nullptr);
thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kCompile));
}
// Avoid jumping more than one state at a time.
new_count = std::min(new_count, osr_method_threshold_ - 1);
} else if (starting_count < osr_method_threshold_) {
- if (new_count >= osr_method_threshold_) {
+ if (!with_backedges) {
+ // If the samples don't contain any back edge, we don't increment the hotness.
+ return;
+ }
+ if ((new_count >= osr_method_threshold_) && !code_cache_->IsOsrCompiled(method)) {
DCHECK(thread_pool_ != nullptr);
thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kCompileOsr));
}
@@ -630,7 +642,7 @@
!Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
method->SetEntryPointFromQuickCompiledCode(profiling_info->GetSavedEntryPoint());
} else {
- AddSamples(thread, method, 1);
+ AddSamples(thread, method, 1, /* with_backedges */false);
}
}
diff --git a/runtime/jit/jit.h b/runtime/jit/jit.h
index 96f9608..ff3acf6 100644
--- a/runtime/jit/jit.h
+++ b/runtime/jit/jit.h
@@ -43,6 +43,8 @@
public:
static constexpr bool kStressMode = kIsDebugBuild;
static constexpr size_t kDefaultCompileThreshold = kStressMode ? 2 : 10000;
+ static constexpr size_t kDefaultPriorityThreadWeightRatio = 1000;
+ static constexpr size_t kDefaultTransitionRatio = 100;
virtual ~Jit();
static Jit* Create(JitOptions* options, std::string* error_msg);
@@ -92,7 +94,7 @@
void MethodEntered(Thread* thread, ArtMethod* method)
SHARED_REQUIRES(Locks::mutator_lock_);
- void AddSamples(Thread* self, ArtMethod* method, uint16_t samples)
+ void AddSamples(Thread* self, ArtMethod* method, uint16_t samples, bool with_backedges)
SHARED_REQUIRES(Locks::mutator_lock_);
void InvokeVirtualOrInterface(Thread* thread,
@@ -102,6 +104,16 @@
ArtMethod* callee)
SHARED_REQUIRES(Locks::mutator_lock_);
+ void NotifyInterpreterToCompiledCodeTransition(Thread* self, ArtMethod* caller)
+ SHARED_REQUIRES(Locks::mutator_lock_) {
+ AddSamples(self, caller, transition_weight_, false);
+ }
+
+ void NotifyCompiledCodeToInterpreterTransition(Thread* self, ArtMethod* callee)
+ SHARED_REQUIRES(Locks::mutator_lock_) {
+ AddSamples(self, callee, transition_weight_, false);
+ }
+
// Starts the profile saver if the config options allow profile recording.
// The profile will be stored in the specified `filename` and will contain
// information collected from the given `code_paths` (a set of dex locations).
@@ -175,6 +187,7 @@
uint16_t warm_method_threshold_;
uint16_t osr_method_threshold_;
uint16_t priority_thread_weight_;
+ uint16_t transition_weight_;
std::unique_ptr<ThreadPool> thread_pool_;
DISALLOW_COPY_AND_ASSIGN(Jit);
diff --git a/runtime/jit/jit_code_cache.cc b/runtime/jit/jit_code_cache.cc
index 820ae6a..1f3e08b 100644
--- a/runtime/jit/jit_code_cache.cc
+++ b/runtime/jit/jit_code_cache.cc
@@ -366,7 +366,7 @@
}
last_update_time_ns_.StoreRelease(NanoTime());
VLOG(jit)
- << "JIT added (osr = " << std::boolalpha << osr << std::noboolalpha << ") "
+ << "JIT added (osr=" << std::boolalpha << osr << std::noboolalpha << ") "
<< PrettyMethod(method) << "@" << method
<< " ccache_size=" << PrettySize(CodeCacheSizeLocked()) << ": "
<< " dcache_size=" << PrettySize(DataCacheSizeLocked()) << ": "
@@ -905,15 +905,18 @@
return last_update_time_ns_.LoadAcquire();
}
+bool JitCodeCache::IsOsrCompiled(ArtMethod* method) {
+ MutexLock mu(Thread::Current(), lock_);
+ return osr_code_map_.find(method) != osr_code_map_.end();
+}
+
bool JitCodeCache::NotifyCompilationOf(ArtMethod* method, Thread* self, bool osr) {
if (!osr && ContainsPc(method->GetEntryPointFromQuickCompiledCode())) {
- VLOG(jit) << PrettyMethod(method) << " is already compiled";
return false;
}
MutexLock mu(self, lock_);
if (osr && (osr_code_map_.find(method) != osr_code_map_.end())) {
- VLOG(jit) << PrettyMethod(method) << " is already osr compiled";
return false;
}
@@ -928,7 +931,6 @@
}
if (info->IsMethodBeingCompiled(osr)) {
- VLOG(jit) << PrettyMethod(method) << " is already being compiled";
return false;
}
diff --git a/runtime/jit/jit_code_cache.h b/runtime/jit/jit_code_cache.h
index 9f18c70..f31cc51 100644
--- a/runtime/jit/jit_code_cache.h
+++ b/runtime/jit/jit_code_cache.h
@@ -186,6 +186,8 @@
void Dump(std::ostream& os) REQUIRES(!lock_);
+ bool IsOsrCompiled(ArtMethod* method) REQUIRES(!lock_);
+
private:
// Take ownership of maps.
JitCodeCache(MemMap* code_map,