Move mterp and switch interpreter to tiered JIT.
This is an intermediate step to move ProfilingInfo usage only within the
baseline compiler.
It also makes the system consistent with all intepreters now going to
baseline compilation before optimized.
Bug: 112676029
Test: test.py
Change-Id: I8505ca46ede9095683ac3f5f86f0c70335bed633
diff --git a/runtime/instrumentation.cc b/runtime/instrumentation.cc
index 23355b1..1838984 100644
--- a/runtime/instrumentation.cc
+++ b/runtime/instrumentation.cc
@@ -928,16 +928,6 @@
// Proxy.<init> correctly in all cases.
method != jni::DecodeArtMethod(WellKnownClasses::java_lang_reflect_Proxy_init)) {
new_quick_code = GetQuickInstrumentationEntryPoint();
- if (!method->IsNative() && Runtime::Current()->GetJit() != nullptr) {
- // Native methods use trampoline entrypoints during interpreter tracing.
- DCHECK(!Runtime::Current()->GetJit()->GetCodeCache()->GetGarbageCollectCodeUnsafe());
- ProfilingInfo* profiling_info = method->GetProfilingInfo(kRuntimePointerSize);
- // Tracing will look at the saved entry point in the profiling info to know the actual
- // entrypoint, so we store it here.
- if (profiling_info != nullptr) {
- profiling_info->SetSavedEntryPoint(quick_code);
- }
- }
} else {
new_quick_code = quick_code;
}
diff --git a/runtime/interpreter/interpreter_common.cc b/runtime/interpreter/interpreter_common.cc
index a3f2e3e..4e88eda 100644
--- a/runtime/interpreter/interpreter_common.cc
+++ b/runtime/interpreter/interpreter_common.cc
@@ -85,10 +85,6 @@
if (method->IsStatic() && !method->GetDeclaringClass()->IsVisiblyInitialized()) {
return false;
}
- ProfilingInfo* profiling_info = method->GetProfilingInfo(kRuntimePointerSize);
- if ((profiling_info != nullptr) && (profiling_info->GetSavedEntryPoint() != nullptr)) {
- return false;
- }
return true;
}
diff --git a/runtime/interpreter/interpreter_common.h b/runtime/interpreter/interpreter_common.h
index 6c272f3..ad6ceae 100644
--- a/runtime/interpreter/interpreter_common.h
+++ b/runtime/interpreter/interpreter_common.h
@@ -299,10 +299,6 @@
}
jit::Jit* jit = Runtime::Current()->GetJit();
- if (jit != nullptr && (type == kVirtual || type == kInterface)) {
- jit->InvokeVirtualOrInterface(receiver, sf_method, shadow_frame.GetDexPC(), called_method);
- }
-
if (is_mterp && !is_range && called_method->IsIntrinsic()) {
if (MterpHandleIntrinsic(&shadow_frame, called_method, inst, inst_data,
shadow_frame.GetResultRegister())) {
diff --git a/runtime/jit/jit.cc b/runtime/jit/jit.cc
index e2df149..8899fa4 100644
--- a/runtime/jit/jit.cc
+++ b/runtime/jit/jit.cc
@@ -1534,45 +1534,14 @@
DCHECK_GE(PriorityThreadWeight(), 1);
DCHECK_LE(PriorityThreadWeight(), HotMethodThreshold());
- if (old_count < WarmMethodThreshold() && new_count >= WarmMethodThreshold()) {
- // Note: Native method have no "warm" state or profiling info.
- if (!method->IsNative() &&
- (method->GetProfilingInfo(kRuntimePointerSize) == nullptr) &&
- code_cache_->CanAllocateProfilingInfo() &&
- !options_->UseTieredJitCompilation()) {
- bool success = ProfilingInfo::Create(self, method, /* retry_allocation= */ false);
- if (success) {
- VLOG(jit) << "Start profiling " << method->PrettyMethod();
- }
-
- if (thread_pool_ == nullptr) {
- // Calling ProfilingInfo::Create might put us in a suspended state, which could
- // lead to the thread pool being deleted when we are shutting down.
- return false;
- }
-
- if (!success) {
- // We failed allocating. Instead of doing the collection on the Java thread, we push
- // an allocation to a compiler thread, that will do the collection.
- thread_pool_->AddTask(
- self,
- new JitCompileTask(method,
- JitCompileTask::TaskKind::kAllocateProfile,
- CompilationKind::kOptimized)); // Arbitrary compilation kind.
- }
- }
- }
if (UseJitCompilation()) {
if (old_count < HotMethodThreshold() && new_count >= HotMethodThreshold()) {
if (!code_cache_->ContainsPc(method->GetEntryPointFromQuickCompiledCode())) {
DCHECK(thread_pool_ != nullptr);
- CompilationKind compilation_kind =
- (options_->UseTieredJitCompilation() || options_->UseBaselineCompiler())
- ? CompilationKind::kBaseline
- : CompilationKind::kOptimized;
thread_pool_->AddTask(
self,
- new JitCompileTask(method, JitCompileTask::TaskKind::kCompile, compilation_kind));
+ new JitCompileTask(
+ method, JitCompileTask::TaskKind::kCompile, CompilationKind::kBaseline));
}
}
if (old_count < OSRMethodThreshold() && new_count >= OSRMethodThreshold()) {
@@ -1643,30 +1612,7 @@
return;
}
- ProfilingInfo* profiling_info = method->GetProfilingInfo(kRuntimePointerSize);
- // Update the entrypoint if the ProfilingInfo has one. The interpreter will call it
- // instead of interpreting the method. We don't update it for instrumentation as the entrypoint
- // must remain the instrumentation entrypoint.
- if ((profiling_info != nullptr) &&
- (profiling_info->GetSavedEntryPoint() != nullptr) &&
- (method->GetEntryPointFromQuickCompiledCode() != GetQuickInstrumentationEntryPoint())) {
- Runtime::Current()->GetInstrumentation()->UpdateMethodsCode(
- method, profiling_info->GetSavedEntryPoint());
- } else {
- AddSamples(thread, method, 1, /* with_backedges= */false);
- }
-}
-
-void Jit::InvokeVirtualOrInterface(ObjPtr<mirror::Object> this_object,
- ArtMethod* caller,
- uint32_t dex_pc,
- ArtMethod* callee ATTRIBUTE_UNUSED) {
- ScopedAssertNoThreadSuspension ants(__FUNCTION__);
- DCHECK(this_object != nullptr);
- ProfilingInfo* info = caller->GetProfilingInfo(kRuntimePointerSize);
- if (info != nullptr) {
- info->AddInvokeInfo(dex_pc, this_object->GetClass());
- }
+ AddSamples(thread, method, 1, /* with_backedges= */false);
}
void Jit::WaitForCompilationToFinish(Thread* self) {
diff --git a/runtime/jit/jit.h b/runtime/jit/jit.h
index 2af58e2..5aa53ff 100644
--- a/runtime/jit/jit.h
+++ b/runtime/jit/jit.h
@@ -121,12 +121,6 @@
return use_tiered_jit_compilation_;
}
- bool CanCompileBaseline() const {
- return use_tiered_jit_compilation_ ||
- use_baseline_compiler_ ||
- interpreter::IsNterpSupported();
- }
-
void SetUseJitCompilation(bool b) {
use_jit_compilation_ = b;
}
@@ -312,12 +306,6 @@
bool with_backedges)
REQUIRES_SHARED(Locks::mutator_lock_);
- void InvokeVirtualOrInterface(ObjPtr<mirror::Object> this_object,
- ArtMethod* caller,
- uint32_t dex_pc,
- ArtMethod* callee)
- REQUIRES_SHARED(Locks::mutator_lock_);
-
void NotifyInterpreterToCompiledCodeTransition(Thread* self, ArtMethod* caller)
REQUIRES_SHARED(Locks::mutator_lock_) {
if (!IgnoreSamplesForMethod(caller)) {
diff --git a/runtime/jit/jit_code_cache.cc b/runtime/jit/jit_code_cache.cc
index 59f1576..a1a96d2 100644
--- a/runtime/jit/jit_code_cache.cc
+++ b/runtime/jit/jit_code_cache.cc
@@ -1191,25 +1191,8 @@
// Start polling the liveness of compiled code to prepare for the next full collection.
if (next_collection_will_be_full) {
- if (Runtime::Current()->GetJITOptions()->CanCompileBaseline()) {
- for (ProfilingInfo* info : profiling_infos_) {
- info->SetBaselineHotnessCount(0);
- }
- } else {
- // Save the entry point of methods we have compiled, and update the entry
- // point of those methods to the interpreter. If the method is invoked, the
- // interpreter will update its entry point to the compiled code and call it.
- for (ProfilingInfo* info : profiling_infos_) {
- const void* entry_point = info->GetMethod()->GetEntryPointFromQuickCompiledCode();
- if (!IsInZygoteDataSpace(info) && ContainsPc(entry_point)) {
- info->SetSavedEntryPoint(entry_point);
- // Don't call Instrumentation::UpdateMethodsCode(), as it can check the declaring
- // class of the method. We may be concurrently running a GC which makes accessing
- // the class unsafe. We know it is OK to bypass the instrumentation as we've just
- // checked that the current entry point is JIT compiled code.
- info->GetMethod()->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
- }
- }
+ for (ProfilingInfo* info : profiling_infos_) {
+ info->SetBaselineHotnessCount(0);
}
// Change entry points of native methods back to the GenericJNI entrypoint.
@@ -1349,54 +1332,24 @@
{
MutexLock mu(self, *Locks::jit_lock_);
- if (Runtime::Current()->GetJITOptions()->CanCompileBaseline()) {
- // Update to interpreter the methods that have baseline entrypoints and whose baseline
- // hotness count is zero.
- // Note that these methods may be in thread stack or concurrently revived
- // between. That's OK, as the thread executing it will mark it.
- for (ProfilingInfo* info : profiling_infos_) {
- if (info->GetBaselineHotnessCount() == 0) {
- const void* entry_point = info->GetMethod()->GetEntryPointFromQuickCompiledCode();
- if (ContainsPc(entry_point)) {
- OatQuickMethodHeader* method_header =
- OatQuickMethodHeader::FromEntryPoint(entry_point);
- if (CodeInfo::IsBaseline(method_header->GetOptimizedCodeInfoPtr())) {
- info->GetMethod()->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
- }
+ // Update to interpreter the methods that have baseline entrypoints and whose baseline
+ // hotness count is zero.
+ // Note that these methods may be in thread stack or concurrently revived
+ // between. That's OK, as the thread executing it will mark it.
+ for (ProfilingInfo* info : profiling_infos_) {
+ if (info->GetBaselineHotnessCount() == 0) {
+ const void* entry_point = info->GetMethod()->GetEntryPointFromQuickCompiledCode();
+ if (ContainsPc(entry_point)) {
+ OatQuickMethodHeader* method_header =
+ OatQuickMethodHeader::FromEntryPoint(entry_point);
+ if (CodeInfo::IsBaseline(method_header->GetOptimizedCodeInfoPtr())) {
+ info->GetMethod()->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge());
}
}
}
- // TODO: collect profiling info
- // TODO: collect optimized code?
- } else {
- if (collect_profiling_info) {
- // Clear the profiling info of methods that do not have compiled code as entrypoint.
- // Also remove the saved entry point from the ProfilingInfo objects.
- for (ProfilingInfo* info : profiling_infos_) {
- const void* ptr = info->GetMethod()->GetEntryPointFromQuickCompiledCode();
- if (!ContainsPc(ptr) &&
- !IsMethodBeingCompiled(info->GetMethod()) &&
- !info->IsInUseByCompiler() &&
- !IsInZygoteDataSpace(info)) {
- info->GetMethod()->SetProfilingInfo(nullptr);
- }
-
- if (info->GetSavedEntryPoint() != nullptr) {
- info->SetSavedEntryPoint(nullptr);
- // We are going to move this method back to interpreter. Clear the counter now to
- // give it a chance to be hot again.
- ClearMethodCounter(info->GetMethod(), /*was_warm=*/ true);
- }
- }
- } else if (kIsDebugBuild) {
- // Check that the profiling infos do not have a dangling entry point.
- for (ProfilingInfo* info : profiling_infos_) {
- DCHECK(!Runtime::Current()->IsZygote());
- const void* entry_point = info->GetSavedEntryPoint();
- DCHECK(entry_point == nullptr || IsInZygoteExecSpace(entry_point));
- }
- }
}
+ // TODO: collect profiling info
+ // TODO: collect optimized code
// Mark compiled code that are entrypoints of ArtMethods. Compiled code that is not
// an entry point is either: