/*
|
* 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/histogram-inl.h"
|
#include "base/macros.h"
|
#include "base/mutex.h"
|
#include "base/timing_logger.h"
|
#include "handle.h"
|
#include "jit/profile_saver_options.h"
|
#include "obj_ptr.h"
|
#include "thread_pool.h"
|
|
namespace art {
|
|
class ArtMethod;
|
class ClassLinker;
|
class DexFile;
|
class OatDexFile;
|
struct RuntimeArgumentMap;
|
union JValue;
|
|
namespace mirror {
|
class Object;
|
class Class;
|
class ClassLoader;
|
} // namespace mirror
|
|
namespace jit {
|
|
class JitCodeCache;
|
class JitOptions;
|
|
static constexpr int16_t kJitCheckForOSR = -1;
|
static constexpr int16_t kJitHotnessDisabled = -2;
|
// At what priority to schedule jit threads. 9 is the lowest foreground priority on device.
|
// See android/os/Process.java.
|
static constexpr int kJitPoolThreadPthreadDefaultPriority = 9;
|
static constexpr uint32_t kJitSamplesBatchSize = 32; // Must be power of 2.
|
|
class JitOptions {
|
public:
|
static JitOptions* CreateFromRuntimeArguments(const RuntimeArgumentMap& options);
|
|
uint16_t GetCompileThreshold() const {
|
return compile_threshold_;
|
}
|
|
uint16_t GetWarmupThreshold() const {
|
return warmup_threshold_;
|
}
|
|
uint16_t GetOsrThreshold() const {
|
return osr_threshold_;
|
}
|
|
uint16_t GetPriorityThreadWeight() const {
|
return priority_thread_weight_;
|
}
|
|
uint16_t GetInvokeTransitionWeight() const {
|
return invoke_transition_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_;
|
}
|
|
const ProfileSaverOptions& GetProfileSaverOptions() const {
|
return profile_saver_options_;
|
}
|
|
bool GetSaveProfilingInfo() const {
|
return profile_saver_options_.IsEnabled();
|
}
|
|
int GetThreadPoolPthreadPriority() const {
|
return thread_pool_pthread_priority_;
|
}
|
|
bool UseJitCompilation() const {
|
return use_jit_compilation_;
|
}
|
|
void SetUseJitCompilation(bool b) {
|
use_jit_compilation_ = b;
|
}
|
|
void SetSaveProfilingInfo(bool save_profiling_info) {
|
profile_saver_options_.SetEnabled(save_profiling_info);
|
}
|
|
void SetWaitForJitNotificationsToSaveProfile(bool value) {
|
profile_saver_options_.SetWaitForJitNotificationsToSave(value);
|
}
|
|
void SetProfileAOTCode(bool value) {
|
profile_saver_options_.SetProfileAOTCode(value);
|
}
|
|
void SetJitAtFirstUse() {
|
use_jit_compilation_ = true;
|
compile_threshold_ = 0;
|
}
|
|
private:
|
// We add the sample in batches of size kJitSamplesBatchSize.
|
// This method rounds the threshold so that it is multiple of the batch size.
|
static uint32_t RoundUpThreshold(uint32_t threshold);
|
|
bool use_jit_compilation_;
|
size_t code_cache_initial_capacity_;
|
size_t code_cache_max_capacity_;
|
uint32_t compile_threshold_;
|
uint32_t warmup_threshold_;
|
uint32_t osr_threshold_;
|
uint16_t priority_thread_weight_;
|
uint16_t invoke_transition_weight_;
|
bool dump_info_on_shutdown_;
|
int thread_pool_pthread_priority_;
|
ProfileSaverOptions profile_saver_options_;
|
|
JitOptions()
|
: use_jit_compilation_(false),
|
code_cache_initial_capacity_(0),
|
code_cache_max_capacity_(0),
|
compile_threshold_(0),
|
warmup_threshold_(0),
|
osr_threshold_(0),
|
priority_thread_weight_(0),
|
invoke_transition_weight_(0),
|
dump_info_on_shutdown_(false),
|
thread_pool_pthread_priority_(kJitPoolThreadPthreadDefaultPriority) {}
|
|
DISALLOW_COPY_AND_ASSIGN(JitOptions);
|
};
|
|
class Jit {
|
public:
|
static constexpr size_t kDefaultPriorityThreadWeightRatio = 1000;
|
static constexpr size_t kDefaultInvokeTransitionWeightRatio = 500;
|
// How frequently should the interpreter check to see if OSR compilation is ready.
|
static constexpr int16_t kJitRecheckOSRThreshold = 101; // Prime number to avoid patterns.
|
|
virtual ~Jit();
|
|
// Create JIT itself.
|
static Jit* Create(JitCodeCache* code_cache, JitOptions* options);
|
|
bool CompileMethod(ArtMethod* method, Thread* self, bool baseline, bool osr)
|
REQUIRES_SHARED(Locks::mutator_lock_);
|
|
const JitCodeCache* GetCodeCache() const {
|
return code_cache_;
|
}
|
|
JitCodeCache* GetCodeCache() {
|
return code_cache_;
|
}
|
|
void CreateThreadPool();
|
void DeleteThreadPool();
|
void WaitForWorkersToBeCreated();
|
|
// 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_)
|
REQUIRES_SHARED(Locks::mutator_lock_);
|
|
uint16_t OSRMethodThreshold() const {
|
return options_->GetOsrThreshold();
|
}
|
|
uint16_t HotMethodThreshold() const {
|
return options_->GetCompileThreshold();
|
}
|
|
uint16_t WarmMethodThreshold() const {
|
return options_->GetWarmupThreshold();
|
}
|
|
uint16_t PriorityThreadWeight() const {
|
return options_->GetPriorityThreadWeight();
|
}
|
|
// Returns false if we only need to save profile information and not compile methods.
|
bool UseJitCompilation() const {
|
return options_->UseJitCompilation();
|
}
|
|
bool GetSaveProfilingInfo() const {
|
return options_->GetSaveProfilingInfo();
|
}
|
|
// Wait until there is no more pending compilation tasks.
|
void WaitForCompilationToFinish(Thread* self);
|
|
// Profiling methods.
|
void MethodEntered(Thread* thread, ArtMethod* method)
|
REQUIRES_SHARED(Locks::mutator_lock_);
|
|
ALWAYS_INLINE void AddSamples(Thread* self,
|
ArtMethod* method,
|
uint16_t samples,
|
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_) {
|
AddSamples(self, caller, options_->GetInvokeTransitionWeight(), false);
|
}
|
|
void NotifyCompiledCodeToInterpreterTransition(Thread* self, ArtMethod* callee)
|
REQUIRES_SHARED(Locks::mutator_lock_) {
|
AddSamples(self, callee, options_->GetInvokeTransitionWeight(), 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).
|
void StartProfileSaver(const std::string& filename,
|
const std::vector<std::string>& code_paths);
|
void StopProfileSaver();
|
|
void DumpForSigQuit(std::ostream& os) REQUIRES(!lock_);
|
|
static void NewTypeLoadedIfUsingJit(mirror::Class* type)
|
REQUIRES_SHARED(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(Thread* self);
|
|
// 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)
|
REQUIRES_SHARED(Locks::mutator_lock_);
|
|
// Load the compiler library.
|
static bool LoadCompilerLibrary(std::string* error_msg);
|
|
ThreadPool* GetThreadPool() const {
|
return thread_pool_.get();
|
}
|
|
// Stop the JIT by waiting for all current compilations and enqueued compilations to finish.
|
void Stop();
|
|
// Start JIT threads.
|
void Start();
|
|
// Transition to a child state.
|
void PostForkChildAction(bool is_system_server, bool is_zygote);
|
|
// Prepare for forking.
|
void PreZygoteFork();
|
|
// Adjust state after forking.
|
void PostZygoteFork();
|
|
// Compile methods from the given profile. If `add_to_queue` is true, methods
|
// in the profile are added to the JIT queue. Otherwise they are compiled
|
// directly.
|
void CompileMethodsFromProfile(Thread* self,
|
const std::vector<const DexFile*>& dex_files,
|
const std::string& profile_path,
|
Handle<mirror::ClassLoader> class_loader,
|
bool add_to_queue);
|
|
// Register the dex files to the JIT. This is to perform any compilation/optimization
|
// at the point of loading the dex files.
|
void RegisterDexFiles(const std::vector<std::unique_ptr<const DexFile>>& dex_files,
|
ObjPtr<mirror::ClassLoader> class_loader);
|
|
private:
|
Jit(JitCodeCache* code_cache, JitOptions* options);
|
|
// Compile the method if the number of samples passes a threshold.
|
// Returns false if we can not compile now - don't increment the counter and retry later.
|
bool MaybeCompileMethod(Thread* self,
|
ArtMethod* method,
|
uint32_t old_count,
|
uint32_t new_count,
|
bool with_backedges)
|
REQUIRES_SHARED(Locks::mutator_lock_);
|
|
static bool BindCompilerMethods(std::string* error_msg);
|
|
// JIT compiler
|
static void* jit_library_handle_;
|
static void* jit_compiler_handle_;
|
static void* (*jit_load_)(void);
|
static void (*jit_unload_)(void*);
|
static bool (*jit_compile_method_)(void*, ArtMethod*, Thread*, bool, bool);
|
static void (*jit_types_loaded_)(void*, mirror::Class**, size_t count);
|
static void (*jit_update_options_)(void*);
|
static bool (*jit_generate_debug_info_)(void*);
|
template <typename T> static bool LoadSymbol(T*, const char* symbol, std::string* error_msg);
|
|
// JIT resources owned by runtime.
|
jit::JitCodeCache* const code_cache_;
|
const JitOptions* const options_;
|
|
std::unique_ptr<ThreadPool> thread_pool_;
|
std::vector<std::unique_ptr<OatDexFile>> type_lookup_tables_;
|
|
// Performance monitoring.
|
CumulativeLogger cumulative_timings_;
|
Histogram<uint64_t> memory_use_ GUARDED_BY(lock_);
|
Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
|
|
DISALLOW_COPY_AND_ASSIGN(Jit);
|
};
|
|
// Helper class to stop the JIT for a given scope. This will wait for the JIT to quiesce.
|
class ScopedJitSuspend {
|
public:
|
ScopedJitSuspend();
|
~ScopedJitSuspend();
|
|
private:
|
bool was_on_;
|
};
|
|
} // namespace jit
|
} // namespace art
|
|
#endif // ART_RUNTIME_JIT_JIT_H_
|
