runtime/jit/jit_instrumentation.cc - platform/art - Gitiles

 /*
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "jit_instrumentation.h"

 #include "art_method-inl.h"
 #include "jit.h"
 #include "jit_code_cache.h"
 #include "scoped_thread_state_change.h"
 #include "thread_list.h"

 namespace art {
 namespace jit {

 // At what priority to schedule jit threads. 9 is the lowest foreground priority on device.
 static constexpr int kJitPoolThreadPthreadPriority = 9;

 class JitCompileTask FINAL : public Task {
  public:
   enum TaskKind {
     kAllocateProfile,
     kCompile,
     kCompileOsr
   };

   JitCompileTask(ArtMethod* method, TaskKind kind) : method_(method), kind_(kind) {
     ScopedObjectAccess soa(Thread::Current());
     // Add a global ref to the class to prevent class unloading until compilation is done.
     klass_ = soa.Vm()->AddGlobalRef(soa.Self(), method_->GetDeclaringClass());
     CHECK(klass_ != nullptr);
   }

   ~JitCompileTask() {
     ScopedObjectAccess soa(Thread::Current());
     soa.Vm()->DeleteGlobalRef(soa.Self(), klass_);
   }

   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_);
       }
     } 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_);
       }
     } else {
       DCHECK(kind_ == kAllocateProfile);
       if (ProfilingInfo::Create(self, method_, /* retry_allocation */ true)) {
         VLOG(jit) << "Start profiling " << PrettyMethod(method_);
       }
     }
   }

   void Finalize() OVERRIDE {
     delete this;
   }

  private:
   ArtMethod* const method_;
   const TaskKind kind_;
   jobject klass_;

   DISALLOW_IMPLICIT_CONSTRUCTORS(JitCompileTask);
 };

 JitInstrumentationCache::JitInstrumentationCache(uint16_t hot_method_threshold,
                                                  uint16_t warm_method_threshold,
                                                  uint16_t osr_method_threshold,
                                                  uint16_t priority_thread_weight)
     : hot_method_threshold_(hot_method_threshold),
       warm_method_threshold_(warm_method_threshold),
       osr_method_threshold_(osr_method_threshold),
       priority_thread_weight_(priority_thread_weight),
       listener_(this) {
 }

 void JitInstrumentationCache::CreateThreadPool() {
   // Create the thread pool before setting the instrumentation, so that
   // when the threads stopped being suspended, they can use it directly.
   // There is a DCHECK in the 'AddSamples' method to ensure the tread pool
   // is not null when we instrument.
   thread_pool_.reset(new ThreadPool("Jit thread pool", 1));
   thread_pool_->SetPthreadPriority(kJitPoolThreadPthreadPriority);
   thread_pool_->StartWorkers(Thread::Current());
   {
     // Add Jit interpreter instrumentation, tells the interpreter when
     // to notify the jit to compile something.
     ScopedSuspendAll ssa(__FUNCTION__);
     Runtime::Current()->GetInstrumentation()->AddListener(
         &listener_, JitInstrumentationListener::kJitEvents);
   }
 }

 void JitInstrumentationCache::DeleteThreadPool(Thread* self) {
   DCHECK(Runtime::Current()->IsShuttingDown(self));
   if (thread_pool_ != nullptr) {
     // First remove the listener, to avoid having mutators enter
     // 'AddSamples'.
     ThreadPool* cache = nullptr;
     {
       ScopedSuspendAll ssa(__FUNCTION__);
       Runtime::Current()->GetInstrumentation()->RemoveListener(
           &listener_, JitInstrumentationListener::kJitEvents);
       // Clear thread_pool_ field while the threads are suspended.
       // A mutator in the 'AddSamples' method will check against it.
       cache = thread_pool_.release();
     }
     cache->StopWorkers(self);
     cache->RemoveAllTasks(self);
     // We could just suspend all threads, but we know those threads
     // will finish in a short period, so it's not worth adding a suspend logic
     // here. Besides, this is only done for shutdown.
     cache->Wait(self, false, false);
     delete cache;
   }
 }

 void JitInstrumentationCache::AddSamples(Thread* self, ArtMethod* method, uint16_t count) {
   // Since we don't have on-stack replacement, some methods can remain in the interpreter longer
   // than we want resulting in samples even after the method is compiled.  Also, if the
   // jit is no longer interested in hotness samples because we're shutting down, just return.
   if (method->IsClassInitializer() || method->IsNative() || (thread_pool_ == nullptr)) {
     if (thread_pool_ == nullptr) {
       // Should only see this when shutting down.
       DCHECK(Runtime::Current()->IsShuttingDown(self));
     }
     return;
   }
   DCHECK(thread_pool_ != nullptr);
   DCHECK_GT(warm_method_threshold_, 0);
   DCHECK_GT(hot_method_threshold_, warm_method_threshold_);
   DCHECK_GT(osr_method_threshold_, hot_method_threshold_);
   DCHECK_GE(priority_thread_weight_, 1);
   DCHECK_LE(priority_thread_weight_, hot_method_threshold_);

   int32_t starting_count = method->GetCounter();
   if (Jit::ShouldUsePriorityThreadWeight()) {
     count *= priority_thread_weight_;
   }
   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_) {
       bool success = ProfilingInfo::Create(self, method, /* retry_allocation */ false);
       if (success) {
         VLOG(jit) << "Start profiling " << PrettyMethod(method);
       }

       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.
         DCHECK(Runtime::Current()->IsShuttingDown(self));
         return;
       }

       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::kAllocateProfile));
       }
     }
     // 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_) {
       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_) {
       DCHECK(thread_pool_ != nullptr);
       thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kCompileOsr));
     }
   }
   // Update hotness counter
   method->SetCounter(new_count);
 }

 JitInstrumentationListener::JitInstrumentationListener(JitInstrumentationCache* cache)
     : instrumentation_cache_(cache) {
   CHECK(instrumentation_cache_ != nullptr);
 }

 void JitInstrumentationListener::MethodEntered(Thread* thread,
                                                mirror::Object* /*this_object*/,
                                                ArtMethod* method,
                                                uint32_t /*dex_pc*/) {
   if (UNLIKELY(Runtime::Current()->GetJit()->JitAtFirstUse())) {
     // The compiler requires a ProfilingInfo object.
     ProfilingInfo::Create(thread, method, /* retry_allocation */ true);
     JitCompileTask compile_task(method, JitCompileTask::kCompile);
     compile_task.Run(thread);
     return;
   }

   ProfilingInfo* profiling_info = method->GetProfilingInfo(sizeof(void*));
   // Update the entrypoint if the ProfilingInfo has one. The interpreter will call it
   // instead of interpreting the method.
   // We avoid doing this if exit stubs are installed to not mess with the instrumentation.
   // TODO(ngeoffray): Clean up instrumentation and code cache interactions.
   if ((profiling_info != nullptr) &&
       (profiling_info->GetSavedEntryPoint() != nullptr) &&
       !Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
     method->SetEntryPointFromQuickCompiledCode(profiling_info->GetSavedEntryPoint());
   } else {
     instrumentation_cache_->AddSamples(thread, method, 1);
   }
 }

 void JitInstrumentationListener::Branch(Thread* thread,
                                         ArtMethod* method,
                                         uint32_t dex_pc ATTRIBUTE_UNUSED,
                                         int32_t dex_pc_offset) {
   if (dex_pc_offset < 0) {
     // Increment method hotness if it is a backward branch.
     instrumentation_cache_->AddSamples(thread, method, 1);
   }
 }

 void JitInstrumentationListener::InvokeVirtualOrInterface(Thread* thread,
                                                           mirror::Object* this_object,
                                                           ArtMethod* caller,
                                                           uint32_t dex_pc,
                                                           ArtMethod* callee ATTRIBUTE_UNUSED) {
   // We make sure we cannot be suspended, as the profiling info can be concurrently deleted.
   instrumentation_cache_->AddSamples(thread, caller, 1);
   DCHECK(this_object != nullptr);
   ProfilingInfo* info = caller->GetProfilingInfo(sizeof(void*));
   if (info != nullptr) {
     // Since the instrumentation is marked from the declaring class we need to mark the card so
     // that mod-union tables and card rescanning know about the update.
     Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(caller->GetDeclaringClass());
     info->AddInvokeInfo(dex_pc, this_object->GetClass());
   }
 }

 void JitInstrumentationCache::WaitForCompilationToFinish(Thread* self) {
   if (thread_pool_ != nullptr) {
     thread_pool_->Wait(self, false, false);
   }
 }

 }  // namespace jit
 }  // namespace art
	/*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "jit_instrumentation.h"

	#include "art_method-inl.h"
	#include "jit.h"
	#include "jit_code_cache.h"
	#include "scoped_thread_state_change.h"
	#include "thread_list.h"

	namespace art {
	namespace jit {

	// At what priority to schedule jit threads. 9 is the lowest foreground priority on device.
	static constexpr int kJitPoolThreadPthreadPriority = 9;

	class JitCompileTask FINAL : public Task {
	public:
	enum TaskKind {
	kAllocateProfile,
	kCompile,
	kCompileOsr
	};

	JitCompileTask(ArtMethod* method, TaskKind kind) : method_(method), kind_(kind) {
	ScopedObjectAccess soa(Thread::Current());
	// Add a global ref to the class to prevent class unloading until compilation is done.
	klass_ = soa.Vm()->AddGlobalRef(soa.Self(), method_->GetDeclaringClass());
	CHECK(klass_ != nullptr);
	}

	~JitCompileTask() {
	ScopedObjectAccess soa(Thread::Current());
	soa.Vm()->DeleteGlobalRef(soa.Self(), klass_);
	}

	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_);
	}
	} 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_);
	}
	} else {
	DCHECK(kind_ == kAllocateProfile);
	if (ProfilingInfo::Create(self, method_, /* retry_allocation */ true)) {
	VLOG(jit) << "Start profiling " << PrettyMethod(method_);
	}
	}
	}

	void Finalize() OVERRIDE {
	delete this;
	}

	private:
	ArtMethod* const method_;
	const TaskKind kind_;
	jobject klass_;

	DISALLOW_IMPLICIT_CONSTRUCTORS(JitCompileTask);
	};

	JitInstrumentationCache::JitInstrumentationCache(uint16_t hot_method_threshold,
	uint16_t warm_method_threshold,
	uint16_t osr_method_threshold,
	uint16_t priority_thread_weight)
	: hot_method_threshold_(hot_method_threshold),
	warm_method_threshold_(warm_method_threshold),
	osr_method_threshold_(osr_method_threshold),
	priority_thread_weight_(priority_thread_weight),
	listener_(this) {
	}

	void JitInstrumentationCache::CreateThreadPool() {
	// Create the thread pool before setting the instrumentation, so that
	// when the threads stopped being suspended, they can use it directly.
	// There is a DCHECK in the 'AddSamples' method to ensure the tread pool
	// is not null when we instrument.
	thread_pool_.reset(new ThreadPool("Jit thread pool", 1));
	thread_pool_->SetPthreadPriority(kJitPoolThreadPthreadPriority);
	thread_pool_->StartWorkers(Thread::Current());
	{
	// Add Jit interpreter instrumentation, tells the interpreter when
	// to notify the jit to compile something.
	ScopedSuspendAll ssa(__FUNCTION__);
	Runtime::Current()->GetInstrumentation()->AddListener(
	&listener_, JitInstrumentationListener::kJitEvents);
	}
	}

	void JitInstrumentationCache::DeleteThreadPool(Thread* self) {
	DCHECK(Runtime::Current()->IsShuttingDown(self));
	if (thread_pool_ != nullptr) {
	// First remove the listener, to avoid having mutators enter
	// 'AddSamples'.
	ThreadPool* cache = nullptr;
	{
	ScopedSuspendAll ssa(__FUNCTION__);
	Runtime::Current()->GetInstrumentation()->RemoveListener(
	&listener_, JitInstrumentationListener::kJitEvents);
	// Clear thread_pool_ field while the threads are suspended.
	// A mutator in the 'AddSamples' method will check against it.
	cache = thread_pool_.release();
	}
	cache->StopWorkers(self);
	cache->RemoveAllTasks(self);
	// We could just suspend all threads, but we know those threads
	// will finish in a short period, so it's not worth adding a suspend logic
	// here. Besides, this is only done for shutdown.
	cache->Wait(self, false, false);
	delete cache;
	}
	}

	void JitInstrumentationCache::AddSamples(Thread* self, ArtMethod* method, uint16_t count) {
	// Since we don't have on-stack replacement, some methods can remain in the interpreter longer
	// than we want resulting in samples even after the method is compiled. Also, if the
	// jit is no longer interested in hotness samples because we're shutting down, just return.
	if (method->IsClassInitializer() \|\| method->IsNative() \|\| (thread_pool_ == nullptr)) {
	if (thread_pool_ == nullptr) {
	// Should only see this when shutting down.
	DCHECK(Runtime::Current()->IsShuttingDown(self));
	}
	return;
	}
	DCHECK(thread_pool_ != nullptr);
	DCHECK_GT(warm_method_threshold_, 0);
	DCHECK_GT(hot_method_threshold_, warm_method_threshold_);
	DCHECK_GT(osr_method_threshold_, hot_method_threshold_);
	DCHECK_GE(priority_thread_weight_, 1);
	DCHECK_LE(priority_thread_weight_, hot_method_threshold_);

	int32_t starting_count = method->GetCounter();
	if (Jit::ShouldUsePriorityThreadWeight()) {
	count *= priority_thread_weight_;
	}
	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_) {
	bool success = ProfilingInfo::Create(self, method, /* retry_allocation */ false);
	if (success) {
	VLOG(jit) << "Start profiling " << PrettyMethod(method);
	}

	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.
	DCHECK(Runtime::Current()->IsShuttingDown(self));
	return;
	}

	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::kAllocateProfile));
	}
	}
	// 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_) {
	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_) {
	DCHECK(thread_pool_ != nullptr);
	thread_pool_->AddTask(self, new JitCompileTask(method, JitCompileTask::kCompileOsr));
	}
	}
	// Update hotness counter
	method->SetCounter(new_count);
	}

	JitInstrumentationListener::JitInstrumentationListener(JitInstrumentationCache* cache)
	: instrumentation_cache_(cache) {
	CHECK(instrumentation_cache_ != nullptr);
	}

	void JitInstrumentationListener::MethodEntered(Thread* thread,
	mirror::Object* /this_object/,
	ArtMethod* method,
	uint32_t /dex_pc/) {
	if (UNLIKELY(Runtime::Current()->GetJit()->JitAtFirstUse())) {
	// The compiler requires a ProfilingInfo object.
	ProfilingInfo::Create(thread, method, /* retry_allocation */ true);
	JitCompileTask compile_task(method, JitCompileTask::kCompile);
	compile_task.Run(thread);
	return;
	}

	ProfilingInfo* profiling_info = method->GetProfilingInfo(sizeof(void*));
	// Update the entrypoint if the ProfilingInfo has one. The interpreter will call it
	// instead of interpreting the method.
	// We avoid doing this if exit stubs are installed to not mess with the instrumentation.
	// TODO(ngeoffray): Clean up instrumentation and code cache interactions.
	if ((profiling_info != nullptr) &&
	(profiling_info->GetSavedEntryPoint() != nullptr) &&
	!Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
	method->SetEntryPointFromQuickCompiledCode(profiling_info->GetSavedEntryPoint());
	} else {
	instrumentation_cache_->AddSamples(thread, method, 1);
	}
	}

	void JitInstrumentationListener::Branch(Thread* thread,
	ArtMethod* method,
	uint32_t dex_pc ATTRIBUTE_UNUSED,
	int32_t dex_pc_offset) {
	if (dex_pc_offset < 0) {
	// Increment method hotness if it is a backward branch.
	instrumentation_cache_->AddSamples(thread, method, 1);
	}
	}

	void JitInstrumentationListener::InvokeVirtualOrInterface(Thread* thread,
	mirror::Object* this_object,
	ArtMethod* caller,
	uint32_t dex_pc,
	ArtMethod* callee ATTRIBUTE_UNUSED) {
	// We make sure we cannot be suspended, as the profiling info can be concurrently deleted.
	instrumentation_cache_->AddSamples(thread, caller, 1);
	DCHECK(this_object != nullptr);
	ProfilingInfo* info = caller->GetProfilingInfo(sizeof(void*));
	if (info != nullptr) {
	// Since the instrumentation is marked from the declaring class we need to mark the card so
	// that mod-union tables and card rescanning know about the update.
	Runtime::Current()->GetHeap()->WriteBarrierEveryFieldOf(caller->GetDeclaringClass());
	info->AddInvokeInfo(dex_pc, this_object->GetClass());
	}
	}

	void JitInstrumentationCache::WaitForCompilationToFinish(Thread* self) {
	if (thread_pool_ != nullptr) {
	thread_pool_->Wait(self, false, false);
	}
	}

	} // namespace jit
	} // namespace art