runtime/jit/jit.h - 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.
  */

 #ifndef ART_RUNTIME_JIT_JIT_H_
 #define ART_RUNTIME_JIT_JIT_H_

 #include "base/arena_allocator.h"
 #include "base/histogram-inl.h"
 #include "base/macros.h"
 #include "base/mutex.h"
 #include "base/timing_logger.h"
 #include "object_callbacks.h"
 #include "offline_profiling_info.h"
 #include "thread_pool.h"

 namespace art {

 class ArtMethod;
 struct RuntimeArgumentMap;

 namespace jit {

 class JitCodeCache;
 class JitOptions;

 static constexpr int16_t kJitCheckForOSR = -1;
 static constexpr int16_t kJitHotnessDisabled = -2;

 class Jit {
  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);
   bool CompileMethod(ArtMethod* method, Thread* self, bool osr)
       SHARED_REQUIRES(Locks::mutator_lock_);
   void CreateThreadPool();

   const JitCodeCache* GetCodeCache() const {
     return code_cache_.get();
   }

   JitCodeCache* GetCodeCache() {
     return code_cache_.get();
   }

   void DeleteThreadPool();
   // Dump interesting info: #methods compiled, code vs data size, compile / verify cumulative
   // loggers.
   void DumpInfo(std::ostream& os) REQUIRES(!lock_);
   // Add a timing logger to cumulative_timings_.
   void AddTimingLogger(const TimingLogger& logger);

   void AddMemoryUsage(ArtMethod* method, size_t bytes)
       REQUIRES(!lock_)
       SHARED_REQUIRES(Locks::mutator_lock_);

   size_t OSRMethodThreshold() const {
     return osr_method_threshold_;
   }

   size_t HotMethodThreshold() const {
     return hot_method_threshold_;
   }

   size_t WarmMethodThreshold() const {
     return warm_method_threshold_;
   }

   uint16_t PriorityThreadWeight() const {
     return priority_thread_weight_;
   }

   // Returns false if we only need to save profile information and not compile methods.
   bool UseJitCompilation() const {
     return use_jit_compilation_;
   }

   bool SaveProfilingInfo() const {
     return save_profiling_info_;
   }

   // Wait until there is no more pending compilation tasks.
   void WaitForCompilationToFinish(Thread* self);

   // Profiling methods.
   void MethodEntered(Thread* thread, ArtMethod* method)
       SHARED_REQUIRES(Locks::mutator_lock_);

   void AddSamples(Thread* self, ArtMethod* method, uint16_t samples, bool with_backedges)
       SHARED_REQUIRES(Locks::mutator_lock_);

   void InvokeVirtualOrInterface(Thread* thread,
                                 mirror::Object* this_object,
                                 ArtMethod* caller,
                                 uint32_t dex_pc,
                                 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).
   // The `foreign_dex_profile_path` is the path where the saver will put the
   // profile markers for loaded dex files which are not owned by the application.
   // The `app_dir` is the application directory and is used to decide which
   // dex files belong to the application.
   void StartProfileSaver(const std::string& filename,
                          const std::vector<std::string>& code_paths,
                          const std::string& foreign_dex_profile_path,
                          const std::string& app_dir);
   void StopProfileSaver();

   void DumpForSigQuit(std::ostream& os) REQUIRES(!lock_);

   static void NewTypeLoadedIfUsingJit(mirror::Class* type)
       SHARED_REQUIRES(Locks::mutator_lock_);

   // If debug info generation is turned on then write the type information for types already loaded
   // into the specified class linker to the jit debug interface,
   void DumpTypeInfoForLoadedTypes(ClassLinker* linker);

   // Return whether we should try to JIT compiled code as soon as an ArtMethod is invoked.
   bool JitAtFirstUse();

   // Return whether we can invoke JIT code for `method`.
   bool CanInvokeCompiledCode(ArtMethod* method);

   // Return whether the runtime should use a priority thread weight when sampling.
   static bool ShouldUsePriorityThreadWeight();

   // If an OSR compiled version is available for `method`,
   // and `dex_pc + dex_pc_offset` is an entry point of that compiled
   // version, this method will jump to the compiled code, let it run,
   // and return true afterwards. Return false otherwise.
   static bool MaybeDoOnStackReplacement(Thread* thread,
                                         ArtMethod* method,
                                         uint32_t dex_pc,
                                         int32_t dex_pc_offset,
                                         JValue* result)
       SHARED_REQUIRES(Locks::mutator_lock_);

   static bool LoadCompilerLibrary(std::string* error_msg);

  private:
   Jit();

   static bool LoadCompiler(std::string* error_msg);

   // JIT compiler
   static void* jit_library_handle_;
   static void* jit_compiler_handle_;
   static void* (*jit_load_)(bool*);
   static void (*jit_unload_)(void*);
   static bool (*jit_compile_method_)(void*, ArtMethod*, Thread*, bool);
   static void (*jit_types_loaded_)(void*, mirror::Class**, size_t count);

   // Performance monitoring.
   bool dump_info_on_shutdown_;
   CumulativeLogger cumulative_timings_;
   Histogram<uint64_t> memory_use_ GUARDED_BY(lock_);
   Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;

   std::unique_ptr<jit::JitCodeCache> code_cache_;

   bool use_jit_compilation_;
   bool save_profiling_info_;
   static bool generate_debug_info_;
   uint16_t hot_method_threshold_;
   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);
 };

 class JitOptions {
  public:
   static JitOptions* CreateFromRuntimeArguments(const RuntimeArgumentMap& options);
   size_t GetCompileThreshold() const {
     return compile_threshold_;
   }
   size_t GetWarmupThreshold() const {
     return warmup_threshold_;
   }
   size_t GetOsrThreshold() const {
     return osr_threshold_;
   }
   uint16_t GetPriorityThreadWeight() const {
     return priority_thread_weight_;
   }
   size_t GetCodeCacheInitialCapacity() const {
     return code_cache_initial_capacity_;
   }
   size_t GetCodeCacheMaxCapacity() const {
     return code_cache_max_capacity_;
   }
   bool DumpJitInfoOnShutdown() const {
     return dump_info_on_shutdown_;
   }
   bool GetSaveProfilingInfo() const {
     return save_profiling_info_;
   }
   bool UseJitCompilation() const {
     return use_jit_compilation_;
   }
   void SetUseJitCompilation(bool b) {
     use_jit_compilation_ = b;
   }
   void SetSaveProfilingInfo(bool b) {
     save_profiling_info_ = b;
   }
   void SetJitAtFirstUse() {
     use_jit_compilation_ = true;
     compile_threshold_ = 0;
   }

  private:
   bool use_jit_compilation_;
   size_t code_cache_initial_capacity_;
   size_t code_cache_max_capacity_;
   size_t compile_threshold_;
   size_t warmup_threshold_;
   size_t osr_threshold_;
   uint16_t priority_thread_weight_;
   bool dump_info_on_shutdown_;
   bool save_profiling_info_;

   JitOptions()
       : use_jit_compilation_(false),
         code_cache_initial_capacity_(0),
         code_cache_max_capacity_(0),
         compile_threshold_(0),
         dump_info_on_shutdown_(false),
         save_profiling_info_(false) { }

   DISALLOW_COPY_AND_ASSIGN(JitOptions);
 };

 }  // namespace jit
 }  // namespace art

 #endif  // ART_RUNTIME_JIT_JIT_H_
	/*
	* 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.
	*/

	#ifndef ART_RUNTIME_JIT_JIT_H_
	#define ART_RUNTIME_JIT_JIT_H_

	#include "base/arena_allocator.h"
	#include "base/histogram-inl.h"
	#include "base/macros.h"
	#include "base/mutex.h"
	#include "base/timing_logger.h"
	#include "object_callbacks.h"
	#include "offline_profiling_info.h"
	#include "thread_pool.h"

	namespace art {

	class ArtMethod;
	struct RuntimeArgumentMap;

	namespace jit {

	class JitCodeCache;
	class JitOptions;

	static constexpr int16_t kJitCheckForOSR = -1;
	static constexpr int16_t kJitHotnessDisabled = -2;

	class Jit {
	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);
	bool CompileMethod(ArtMethod* method, Thread* self, bool osr)
	SHARED_REQUIRES(Locks::mutator_lock_);
	void CreateThreadPool();

	const JitCodeCache* GetCodeCache() const {
	return code_cache_.get();
	}

	JitCodeCache* GetCodeCache() {
	return code_cache_.get();
	}

	void DeleteThreadPool();
	// Dump interesting info: #methods compiled, code vs data size, compile / verify cumulative
	// loggers.
	void DumpInfo(std::ostream& os) REQUIRES(!lock_);
	// Add a timing logger to cumulative_timings_.
	void AddTimingLogger(const TimingLogger& logger);

	void AddMemoryUsage(ArtMethod* method, size_t bytes)
	REQUIRES(!lock_)
	SHARED_REQUIRES(Locks::mutator_lock_);

	size_t OSRMethodThreshold() const {
	return osr_method_threshold_;
	}

	size_t HotMethodThreshold() const {
	return hot_method_threshold_;
	}

	size_t WarmMethodThreshold() const {
	return warm_method_threshold_;
	}

	uint16_t PriorityThreadWeight() const {
	return priority_thread_weight_;
	}

	// Returns false if we only need to save profile information and not compile methods.
	bool UseJitCompilation() const {
	return use_jit_compilation_;
	}

	bool SaveProfilingInfo() const {
	return save_profiling_info_;
	}

	// Wait until there is no more pending compilation tasks.
	void WaitForCompilationToFinish(Thread* self);

	// Profiling methods.
	void MethodEntered(Thread* thread, ArtMethod* method)
	SHARED_REQUIRES(Locks::mutator_lock_);

	void AddSamples(Thread* self, ArtMethod* method, uint16_t samples, bool with_backedges)
	SHARED_REQUIRES(Locks::mutator_lock_);

	void InvokeVirtualOrInterface(Thread* thread,
	mirror::Object* this_object,
	ArtMethod* caller,
	uint32_t dex_pc,
	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).
	// The `foreign_dex_profile_path` is the path where the saver will put the
	// profile markers for loaded dex files which are not owned by the application.
	// The `app_dir` is the application directory and is used to decide which
	// dex files belong to the application.
	void StartProfileSaver(const std::string& filename,
	const std::vector<std::string>& code_paths,
	const std::string& foreign_dex_profile_path,
	const std::string& app_dir);
	void StopProfileSaver();

	void DumpForSigQuit(std::ostream& os) REQUIRES(!lock_);

	static void NewTypeLoadedIfUsingJit(mirror::Class* type)
	SHARED_REQUIRES(Locks::mutator_lock_);

	// If debug info generation is turned on then write the type information for types already loaded
	// into the specified class linker to the jit debug interface,
	void DumpTypeInfoForLoadedTypes(ClassLinker* linker);

	// Return whether we should try to JIT compiled code as soon as an ArtMethod is invoked.
	bool JitAtFirstUse();

	// Return whether we can invoke JIT code for `method`.
	bool CanInvokeCompiledCode(ArtMethod* method);

	// Return whether the runtime should use a priority thread weight when sampling.
	static bool ShouldUsePriorityThreadWeight();

	// If an OSR compiled version is available for `method`,
	// and `dex_pc + dex_pc_offset` is an entry point of that compiled
	// version, this method will jump to the compiled code, let it run,
	// and return true afterwards. Return false otherwise.
	static bool MaybeDoOnStackReplacement(Thread* thread,
	ArtMethod* method,
	uint32_t dex_pc,
	int32_t dex_pc_offset,
	JValue* result)
	SHARED_REQUIRES(Locks::mutator_lock_);

	static bool LoadCompilerLibrary(std::string* error_msg);

	private:
	Jit();

	static bool LoadCompiler(std::string* error_msg);

	// JIT compiler
	static void* jit_library_handle_;
	static void* jit_compiler_handle_;
	static void* (jit_load_)(bool);
	static void (jit_unload_)(void);
	static bool (jit_compile_method_)(void, ArtMethod, Thread, bool);
	static void (jit_types_loaded_)(void, mirror::Class**, size_t count);

	// Performance monitoring.
	bool dump_info_on_shutdown_;
	CumulativeLogger cumulative_timings_;
	Histogram<uint64_t> memory_use_ GUARDED_BY(lock_);
	Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;

	std::unique_ptr<jit::JitCodeCache> code_cache_;

	bool use_jit_compilation_;
	bool save_profiling_info_;
	static bool generate_debug_info_;
	uint16_t hot_method_threshold_;
	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);
	};

	class JitOptions {
	public:
	static JitOptions* CreateFromRuntimeArguments(const RuntimeArgumentMap& options);
	size_t GetCompileThreshold() const {
	return compile_threshold_;
	}
	size_t GetWarmupThreshold() const {
	return warmup_threshold_;
	}
	size_t GetOsrThreshold() const {
	return osr_threshold_;
	}
	uint16_t GetPriorityThreadWeight() const {
	return priority_thread_weight_;
	}
	size_t GetCodeCacheInitialCapacity() const {
	return code_cache_initial_capacity_;
	}
	size_t GetCodeCacheMaxCapacity() const {
	return code_cache_max_capacity_;
	}
	bool DumpJitInfoOnShutdown() const {
	return dump_info_on_shutdown_;
	}
	bool GetSaveProfilingInfo() const {
	return save_profiling_info_;
	}
	bool UseJitCompilation() const {
	return use_jit_compilation_;
	}
	void SetUseJitCompilation(bool b) {
	use_jit_compilation_ = b;
	}
	void SetSaveProfilingInfo(bool b) {
	save_profiling_info_ = b;
	}
	void SetJitAtFirstUse() {
	use_jit_compilation_ = true;
	compile_threshold_ = 0;
	}

	private:
	bool use_jit_compilation_;
	size_t code_cache_initial_capacity_;
	size_t code_cache_max_capacity_;
	size_t compile_threshold_;
	size_t warmup_threshold_;
	size_t osr_threshold_;
	uint16_t priority_thread_weight_;
	bool dump_info_on_shutdown_;
	bool save_profiling_info_;

	JitOptions()
	: use_jit_compilation_(false),
	code_cache_initial_capacity_(0),
	code_cache_max_capacity_(0),
	compile_threshold_(0),
	dump_info_on_shutdown_(false),
	save_profiling_info_(false) { }

	DISALLOW_COPY_AND_ASSIGN(JitOptions);
	};

	} // namespace jit
	} // namespace art

	#endif // ART_RUNTIME_JIT_JIT_H_