blob: 50da0dcfab4a026f44bdc82eaf13482d9de76cda [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapiro1fb86202011-06-27 17:43:13 -070016
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_RUNTIME_H_
18#define ART_RUNTIME_RUNTIME_H_
Carl Shapiro1fb86202011-06-27 17:43:13 -070019
Elliott Hughesa0e18062012-04-13 15:59:59 -070020#include <jni.h>
Elliott Hughesc5f7c912011-08-18 14:00:42 -070021#include <stdio.h>
22
Elliott Hughese27955c2011-08-26 15:21:24 -070023#include <iosfwd>
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070024#include <string>
Carl Shapirofc322c72011-07-27 00:20:01 -070025#include <utility>
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070026#include <vector>
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070027
Elliott Hughes76160052012-12-12 16:31:20 -080028#include "base/macros.h"
Elliott Hughese222ee02012-12-13 14:41:43 -080029#include "base/stringpiece.h"
Mathieu Chartier0de9f732013-11-22 17:58:48 -080030#include "gc/collector_type.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070031#include "gc/heap.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070032#include "globals.h"
Elliott Hughes0f3c5532012-03-30 14:51:51 -070033#include "instruction_set.h"
Ian Rogers62d6c772013-02-27 08:32:07 -080034#include "instrumentation.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070035#include "jobject_comparator.h"
Ian Rogers120f1c72012-09-28 17:17:10 -070036#include "locks.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080037#include "root_visitor.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070038#include "runtime_stats.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070039#include "safe_map.h"
Carl Shapirob5573532011-07-12 18:22:59 -070040
Carl Shapiro1fb86202011-06-27 17:43:13 -070041namespace art {
42
Ian Rogers1d54e732013-05-02 21:10:01 -070043namespace gc {
44 class Heap;
45}
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080046namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070047 class ArtMethod;
Ian Rogers1d54e732013-05-02 21:10:01 -070048 class ClassLoader;
Jeff Hao88474b42013-10-23 16:24:40 -070049 template<class T> class ObjectArray;
Ian Rogers1d54e732013-05-02 21:10:01 -070050 template<class T> class PrimitiveArray;
51 typedef PrimitiveArray<int8_t> ByteArray;
52 class String;
53 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080054} // namespace mirror
Mathieu Chartierc528dba2013-11-26 12:00:11 -080055namespace verifier {
56class MethodVerifier;
57}
Carl Shapiro61e019d2011-07-14 16:53:09 -070058class ClassLinker;
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000059class CompilerCallbacks;
Carl Shapirofc322c72011-07-27 00:20:01 -070060class DexFile;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070061class InternTable;
Ian Rogers1b09b092012-08-20 15:35:52 -070062struct JavaVMExt;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070063class MonitorList;
Elliott Hughese27955c2011-08-26 15:21:24 -070064class SignalCatcher;
Carl Shapiro61e019d2011-07-14 16:53:09 -070065class ThreadList;
jeffhao2692b572011-12-16 15:42:28 -080066class Trace;
Carl Shapiro61e019d2011-07-14 16:53:09 -070067
Carl Shapiro1fb86202011-06-27 17:43:13 -070068class Runtime {
69 public:
Elliott Hughesf1a5adc2012-02-10 18:09:35 -080070 typedef std::vector<std::pair<std::string, const void*> > Options;
Brian Carlstrom8a436592011-08-15 21:27:23 -070071
buzbeea024a062013-07-31 10:47:37 -070072 enum CompilerFilter {
73 kInterpretOnly, // Compile nothing.
buzbeea024a062013-07-31 10:47:37 -070074 kSpace, // Maximize space savings.
75 kBalanced, // Try to get the best performance return on compilation investment.
buzbeefe9ca402013-08-21 09:48:11 -070076 kSpeed, // Maximize runtime performance.
77 kEverything // Force compilation (Note: excludes compilaton of class initializers).
buzbeea024a062013-07-31 10:47:37 -070078 };
Anwar Ghuloumc44f68f2013-05-10 13:24:54 -070079
buzbeea024a062013-07-31 10:47:37 -070080 // Guide heuristics to determine whether to compile method if profile data not available.
81#if ART_SMALL_MODE
82 static const CompilerFilter kDefaultCompilerFilter = kInterpretOnly;
83#else
84 static const CompilerFilter kDefaultCompilerFilter = kSpeed;
85#endif
buzbeefe9ca402013-08-21 09:48:11 -070086 static const size_t kDefaultHugeMethodThreshold = 10000;
87 static const size_t kDefaultLargeMethodThreshold = 600;
88 static const size_t kDefaultSmallMethodThreshold = 60;
89 static const size_t kDefaultTinyMethodThreshold = 20;
buzbeea024a062013-07-31 10:47:37 -070090 static const size_t kDefaultNumDexMethodsThreshold = 900;
Anwar Ghuloum8447d842013-04-30 17:27:40 -070091
Brian Carlstrom8a436592011-08-15 21:27:23 -070092 class ParsedOptions {
93 public:
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070094 // returns null if problem parsing and ignore_unrecognized is false
95 static ParsedOptions* Create(const Options& options, bool ignore_unrecognized);
Brian Carlstrom8a436592011-08-15 21:27:23 -070096
Brian Carlstroma004aa92012-02-08 18:05:09 -080097 const std::vector<const DexFile*>* boot_class_path_;
98 std::string boot_class_path_string_;
99 std::string class_path_string_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700100 std::string host_prefix_;
Brian Carlstrom223f20f2012-02-04 23:06:55 -0800101 std::string image_;
Elliott Hughes515a5bc2011-08-17 11:08:34 -0700102 bool check_jni_;
Elliott Hughesa0957642011-09-02 14:27:33 -0700103 std::string jni_trace_;
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000104 CompilerCallbacks* compiler_callbacks_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700105 bool is_zygote_;
Ian Rogers50ffee22012-11-20 11:47:44 -0800106 bool interpreter_only_;
Anwar Ghuloum87183592013-08-14 12:12:19 -0700107 bool is_explicit_gc_disabled_;
Mathieu Chartier692fafd2013-11-29 17:24:40 -0800108 bool use_tlab_;
Mathieu Chartier2775ee42013-08-20 17:43:47 -0700109 size_t long_pause_log_threshold_;
110 size_t long_gc_log_threshold_;
Mathieu Chartierff3b24a2013-11-22 16:04:25 -0800111 bool dump_gc_performance_on_shutdown_;
Mathieu Chartier2775ee42013-08-20 17:43:47 -0700112 bool ignore_max_footprint_;
Brian Carlstrom8a436592011-08-15 21:27:23 -0700113 size_t heap_initial_size_;
114 size_t heap_maximum_size_;
jeffhaoc1160702011-10-27 15:48:45 -0700115 size_t heap_growth_limit_;
Mathieu Chartier0051be62012-10-12 17:47:11 -0700116 size_t heap_min_free_;
117 size_t heap_max_free_;
118 double heap_target_utilization_;
Mathieu Chartier2775ee42013-08-20 17:43:47 -0700119 size_t parallel_gc_threads_;
120 size_t conc_gc_threads_;
Mathieu Chartier0de9f732013-11-22 17:58:48 -0800121 gc::CollectorType collector_type_;
Brian Carlstromf734cf52011-08-17 16:28:14 -0700122 size_t stack_size_;
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700123 size_t max_spins_before_thin_lock_inflation_;
Mathieu Chartiere0a53e92013-08-05 10:17:40 -0700124 bool low_memory_mode_;
Elliott Hughesbb1e8f02011-10-18 14:14:25 -0700125 size_t lock_profiling_threshold_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700126 std::string stack_trace_file_;
jeffhaob5e81852012-03-12 11:15:45 -0700127 bool method_trace_;
128 std::string method_trace_file_;
129 size_t method_trace_file_size_;
Elliott Hughesfc861622011-10-17 17:57:47 -0700130 bool (*hook_is_sensitive_thread_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700131 jint (*hook_vfprintf_)(FILE* stream, const char* format, va_list ap);
132 void (*hook_exit_)(jint status);
133 void (*hook_abort_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700134 std::vector<std::string> properties_;
buzbeea024a062013-07-31 10:47:37 -0700135 CompilerFilter compiler_filter_;
136 size_t huge_method_threshold_;
137 size_t large_method_threshold_;
138 size_t small_method_threshold_;
139 size_t tiny_method_threshold_;
140 size_t num_dex_methods_threshold_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700141 bool sea_ir_mode_;
Dave Allison0aded082013-11-07 13:15:11 -0800142 bool profile_;
143 std::string profile_output_filename_;
144 int profile_period_s_;
145 int profile_duration_s_;
146 int profile_interval_us_;
147 double profile_backoff_coefficient_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700148
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700149 private:
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700150 ParsedOptions() {}
Brian Carlstrom8a436592011-08-15 21:27:23 -0700151 };
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700152
Carl Shapiro61e019d2011-07-14 16:53:09 -0700153 // Creates and initializes a new runtime.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700154 static bool Create(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700155 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700156
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800157 bool IsCompiler() const {
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000158 return compiler_callbacks_ != nullptr;
159 }
160
161 CompilerCallbacks* GetCompilerCallbacks() {
162 return compiler_callbacks_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800163 }
164
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700165 bool IsZygote() const {
166 return is_zygote_;
167 }
168
Anwar Ghuloum87183592013-08-14 12:12:19 -0700169 bool IsExplicitGcDisabled() const {
170 return is_explicit_gc_disabled_;
171 }
172
Brian Carlstrom51c24672013-07-11 16:00:56 -0700173#ifdef ART_SEA_IR_MODE
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700174 bool IsSeaIRMode() const {
175 return sea_ir_mode_;
176 }
Brian Carlstrom51c24672013-07-11 16:00:56 -0700177#endif
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700178
179 void SetSeaIRMode(bool sea_ir_mode) {
180 sea_ir_mode_ = sea_ir_mode;
181 }
182
buzbeea024a062013-07-31 10:47:37 -0700183 CompilerFilter GetCompilerFilter() const {
184 return compiler_filter_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700185 }
186
buzbeea024a062013-07-31 10:47:37 -0700187 void SetCompilerFilter(CompilerFilter compiler_filter) {
188 compiler_filter_ = compiler_filter;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700189 }
190
buzbeea024a062013-07-31 10:47:37 -0700191 size_t GetHugeMethodThreshold() const {
192 return huge_method_threshold_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700193 }
194
buzbeea024a062013-07-31 10:47:37 -0700195 size_t GetLargeMethodThreshold() const {
196 return large_method_threshold_;
197 }
198
199 size_t GetSmallMethodThreshold() const {
200 return small_method_threshold_;
201 }
202
203 size_t GetTinyMethodThreshold() const {
204 return tiny_method_threshold_;
205 }
206
207 size_t GetNumDexMethodsThreshold() const {
208 return num_dex_methods_threshold_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700209 }
210
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700211 const std::string& GetHostPrefix() const {
Elliott Hughes307f75d2011-10-12 18:04:40 -0700212 DCHECK(!IsStarted());
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700213 return host_prefix_;
214 }
215
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700216 // Starts a runtime, which may cause threads to be started and code to run.
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700217 bool Start() UNLOCK_FUNCTION(Locks::mutator_lock_);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700218
Mathieu Chartier590fee92013-09-13 13:46:47 -0700219 bool IsShuttingDown(Thread* self);
220 bool IsShuttingDownLocked() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700221 return shutting_down_;
222 }
223
Ian Rogers120f1c72012-09-28 17:17:10 -0700224 size_t NumberOfThreadsBeingBorn() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
225 return threads_being_born_;
226 }
227
228 void StartThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
229 threads_being_born_++;
230 }
231
232 void EndThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
233
Ian Rogers9af209c2012-06-03 20:50:30 -0700234 bool IsStarted() const {
235 return started_;
236 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700237
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700238 bool IsFinishedStarting() const {
239 return finished_starting_;
240 }
241
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700242 static Runtime* Current() {
243 return instance_;
244 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700245
Elliott Hughesffe67362011-07-17 12:09:27 -0700246 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most
247 // callers should prefer.
248 // This isn't marked ((noreturn)) because then gcc will merge multiple calls
249 // in a single function together. This reduces code size slightly, but means
250 // that the native stack trace we get may point at the wrong call site.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700251 static void Abort() LOCKS_EXCLUDED(Locks::abort_lock_);
Elliott Hughesffe67362011-07-17 12:09:27 -0700252
Ian Rogers365c1022012-06-22 15:05:28 -0700253 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700254 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700255
256 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700257 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700258
Brian Carlstromce888532013-10-10 00:32:58 -0700259 // Returns the system ClassLoader which represents the CLASSPATH.
260 jobject GetSystemClassLoader() const;
261
Elliott Hughes462c9442012-03-23 18:47:50 -0700262 // Attaches the calling native thread to the runtime.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800263 bool AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
264 bool create_peer);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700265
Elliott Hughesbf86d042011-08-31 17:53:14 -0700266 void CallExitHook(jint status);
267
Carl Shapiro61e019d2011-07-14 16:53:09 -0700268 // Detaches the current native thread from the runtime.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700269 void DetachCurrentThread() LOCKS_EXCLUDED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700270
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700271 void DumpForSigQuit(std::ostream& os)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700272 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800273 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700274
Carl Shapiro61e019d2011-07-14 16:53:09 -0700275 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700276
Brian Carlstroma004aa92012-02-08 18:05:09 -0800277 const std::string& GetBootClassPathString() const {
278 return boot_class_path_string_;
279 }
280
281 const std::string& GetClassPathString() const {
282 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700283 }
284
285 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700286 return class_linker_;
287 }
288
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700289 size_t GetDefaultStackSize() const {
290 return default_stack_size_;
291 }
292
Ian Rogers1d54e732013-05-02 21:10:01 -0700293 gc::Heap* GetHeap() const {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800294 return heap_;
295 }
296
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700297 InternTable* GetInternTable() const {
Brian Carlstrome8104522013-10-15 21:56:36 -0700298 DCHECK(intern_table_ != NULL);
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700299 return intern_table_;
300 }
301
Elliott Hughes0af55432011-08-17 18:37:28 -0700302 JavaVMExt* GetJavaVM() const {
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700303 return java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700304 }
305
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700306 size_t GetMaxSpinsBeforeThinkLockInflation() const {
307 return max_spins_before_thin_lock_inflation_;
308 }
309
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700310 MonitorList* GetMonitorList() const {
311 return monitor_list_;
312 }
313
Ian Rogersa436fde2013-08-27 23:34:06 -0700314 mirror::Throwable* GetPreAllocatedOutOfMemoryError() const
315 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes225f5a12012-06-11 11:23:48 -0700316
317 const std::vector<std::string>& GetProperties() const {
318 return properties_;
319 }
320
Elliott Hughesd92bec42011-09-02 17:04:36 -0700321 ThreadList* GetThreadList() const {
322 return thread_list_;
323 }
324
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700325 const char* GetVersion() const {
326 return "2.0.0";
327 }
328
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700329 void DisallowNewSystemWeaks() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
330 void AllowNewSystemWeaks() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
331
Ian Rogers1d54e732013-05-02 21:10:01 -0700332 // Visit all the roots. If only_dirty is true then non-dirty roots won't be visited. If
333 // clean_dirty is true then dirty roots will be marked as non-dirty after visiting.
334 void VisitRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool clean_dirty)
335 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700336
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700337 // Visit all of the roots we can do safely do concurrently.
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800338 void VisitConcurrentRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool clean_dirty)
339 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700340
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700341 // Visit all of the non thread roots, we can do this with mutators unpaused.
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800342 void VisitNonThreadRoots(RootVisitor* visitor, void* arg)
343 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700344
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700345 // Visit all other roots which must be done with mutators suspended.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800346 void VisitNonConcurrentRoots(RootVisitor* visitor, void* arg)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800347 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700348
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700349 // Sweep system weaks, the system weak is deleted if the visitor return nullptr. Otherwise, the
350 // system weak is updated to be the visitor's returned value.
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700351 void SweepSystemWeaks(RootVisitor* visitor, void* arg)
352 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700353
Ian Rogers9af209c2012-06-03 20:50:30 -0700354 // Returns a special method that calls into a trampoline for runtime method resolution
Brian Carlstromea46f952013-07-30 01:26:50 -0700355 mirror::ArtMethod* GetResolutionMethod() const {
Ian Rogers9af209c2012-06-03 20:50:30 -0700356 CHECK(HasResolutionMethod());
357 return resolution_method_;
358 }
359
360 bool HasResolutionMethod() const {
361 return resolution_method_ != NULL;
362 }
363
Brian Carlstromea46f952013-07-30 01:26:50 -0700364 void SetResolutionMethod(mirror::ArtMethod* method) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700365 resolution_method_ = method;
366 }
367
Brian Carlstromea46f952013-07-30 01:26:50 -0700368 mirror::ArtMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800369
Jeff Hao88474b42013-10-23 16:24:40 -0700370 // Returns a special method that calls into a trampoline for runtime imt conflicts
371 mirror::ArtMethod* GetImtConflictMethod() const {
372 CHECK(HasImtConflictMethod());
373 return imt_conflict_method_;
374 }
375
376 bool HasImtConflictMethod() const {
377 return imt_conflict_method_ != NULL;
378 }
379
380 void SetImtConflictMethod(mirror::ArtMethod* method) {
381 imt_conflict_method_ = method;
382 }
383
384 mirror::ArtMethod* CreateImtConflictMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
385
386 // Returns an imt with every entry set to conflict, used as default imt for all classes.
387 mirror::ObjectArray<mirror::ArtMethod>* GetDefaultImt() const {
388 CHECK(HasDefaultImt());
389 return default_imt_;
390 }
391
392 bool HasDefaultImt() const {
393 return default_imt_ != NULL;
394 }
395
396 void SetDefaultImt(mirror::ObjectArray<mirror::ArtMethod>* imt) {
397 default_imt_ = imt;
398 }
399
400 mirror::ObjectArray<mirror::ArtMethod>* CreateDefaultImt(ClassLinker* cl)
401 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
402
Ian Rogersff1ed472011-09-20 13:46:24 -0700403 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700404 enum CalleeSaveType {
405 kSaveAll,
406 kRefsOnly,
407 kRefsAndArgs,
408 kLastCalleeSaveType // Value used for iteration
409 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700410
411 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Elliott Hughes225f5a12012-06-11 11:23:48 -0700412 return callee_save_methods_[type] != NULL;
Ian Rogers9af209c2012-06-03 20:50:30 -0700413 }
414
Brian Carlstromea46f952013-07-30 01:26:50 -0700415 mirror::ArtMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
Ian Rogersdf1ce912012-11-27 17:07:11 -0800416 DCHECK(HasCalleeSaveMethod(type));
Elliott Hughes225f5a12012-06-11 11:23:48 -0700417 return callee_save_methods_[type];
Ian Rogers9af209c2012-06-03 20:50:30 -0700418 }
419
Brian Carlstromea46f952013-07-30 01:26:50 -0700420 void SetCalleeSaveMethod(mirror::ArtMethod* method, CalleeSaveType type);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700421
Brian Carlstromea46f952013-07-30 01:26:50 -0700422 mirror::ArtMethod* CreateCalleeSaveMethod(InstructionSet instruction_set,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800423 CalleeSaveType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700424 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700425
Brian Carlstromea46f952013-07-30 01:26:50 -0700426 mirror::ArtMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700427 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700428
Brian Carlstromea46f952013-07-30 01:26:50 -0700429 mirror::ArtMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700430 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersff1ed472011-09-20 13:46:24 -0700431
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700432 int32_t GetStat(int kind);
433
Ian Rogers9af209c2012-06-03 20:50:30 -0700434 RuntimeStats* GetStats() {
435 return &stats_;
436 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700437
438 bool HasStatsEnabled() const {
439 return stats_enabled_;
440 }
441
442 void ResetStats(int kinds);
443
444 void SetStatsEnabled(bool new_state);
445
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700446 bool PreZygoteFork();
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700447 bool InitZygote();
448 void DidForkFromZygote();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700449
Ian Rogers62d6c772013-02-27 08:32:07 -0800450 instrumentation::Instrumentation* GetInstrumentation() {
451 return &instrumentation_;
452 }
jeffhao2692b572011-12-16 15:42:28 -0800453
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800454 bool UseCompileTimeClassPath() const {
455 return use_compile_time_class_path_;
456 }
Ian Rogers9af209c2012-06-03 20:50:30 -0700457
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800458 void AddMethodVerifier(verifier::MethodVerifier* verifier);
459 void RemoveMethodVerifier(verifier::MethodVerifier* verifier);
460
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700461 const std::vector<const DexFile*>& GetCompileTimeClassPath(jobject class_loader);
462 void SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800463
Dave Allison0aded082013-11-07 13:15:11 -0800464 void StartProfiler(const char *appDir, bool startImmediately = false);
465
Carl Shapirob5573532011-07-12 18:22:59 -0700466 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700467 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700468
Elliott Hughesdcc24742011-09-07 14:02:44 -0700469 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700470
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700471 void BlockSignals();
472
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700473 bool Init(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700474 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
475 void InitNativeMethods() LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers365c1022012-06-22 15:05:28 -0700476 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800477 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700478
Elliott Hughes85d15452011-09-16 17:33:01 -0700479 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700480 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700481
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800482 // A pointer to the active runtime or NULL.
483 static Runtime* instance_;
484
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000485 CompilerCallbacks* compiler_callbacks_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700486 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700487 bool is_concurrent_gc_enabled_;
Anwar Ghuloum87183592013-08-14 12:12:19 -0700488 bool is_explicit_gc_disabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700489
buzbeea024a062013-07-31 10:47:37 -0700490 CompilerFilter compiler_filter_;
491 size_t huge_method_threshold_;
492 size_t large_method_threshold_;
493 size_t small_method_threshold_;
494 size_t tiny_method_threshold_;
495 size_t num_dex_methods_threshold_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700496
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700497 bool sea_ir_mode_;
498
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700499 // The host prefix is used during cross compilation. It is removed
500 // from the start of host paths such as:
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800501 // $ANDROID_PRODUCT_OUT/system/framework/boot.oat
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700502 // to produce target paths such as
Brian Carlstrom47a0d5a2011-10-12 21:20:05 -0700503 // /system/framework/boot.oat
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700504 // Similarly it is prepended to target paths to arrive back at a
505 // host past. In both cases this is necessary because image and oat
506 // files embedded expect paths of dependent files (an image points
507 // to an oat file and an oat files to one or more dex files). These
508 // files contain the expected target path.
509 std::string host_prefix_;
510
Brian Carlstroma004aa92012-02-08 18:05:09 -0800511 std::string boot_class_path_string_;
512 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700513 std::vector<std::string> properties_;
514
Brian Carlstromb765be02011-08-17 23:54:10 -0700515 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700516 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700517
Ian Rogers1d54e732013-05-02 21:10:01 -0700518 gc::Heap* heap_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800519
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700520 // The number of spins that are done before thread suspension is used to forcibly inflate.
521 size_t max_spins_before_thin_lock_inflation_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700522 MonitorList* monitor_list_;
523
Carl Shapirob5573532011-07-12 18:22:59 -0700524 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700525
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700526 InternTable* intern_table_;
527
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700528 ClassLinker* class_linker_;
529
Elliott Hughese27955c2011-08-26 15:21:24 -0700530 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700531 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700532
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700533 JavaVMExt* java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700534
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800535 mirror::Throwable* pre_allocated_OutOfMemoryError_;
Elliott Hughes225f5a12012-06-11 11:23:48 -0700536
Brian Carlstromea46f952013-07-30 01:26:50 -0700537 mirror::ArtMethod* callee_save_methods_[kLastCalleeSaveType];
Ian Rogersff1ed472011-09-20 13:46:24 -0700538
Brian Carlstromea46f952013-07-30 01:26:50 -0700539 mirror::ArtMethod* resolution_method_;
Ian Rogers19846512012-02-24 11:42:47 -0800540
Jeff Hao88474b42013-10-23 16:24:40 -0700541 mirror::ArtMethod* imt_conflict_method_;
542
543 mirror::ObjectArray<mirror::ArtMethod>* default_imt_;
544
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800545 // Method verifier set, used so that we can update their GC roots.
546 Mutex method_verifiers_lock_;
547 std::set<verifier::MethodVerifier*> method_verifiers_;
548
Ian Rogers120f1c72012-09-28 17:17:10 -0700549 // A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
550 // the shutdown lock so that threads aren't born while we're shutting down.
551 size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
552
553 // Waited upon until no threads are being born.
554 UniquePtr<ConditionVariable> shutdown_cond_ GUARDED_BY(Locks::runtime_shutdown_lock_);
555
556 // Set when runtime shutdown is past the point that new threads may attach.
557 bool shutting_down_ GUARDED_BY(Locks::runtime_shutdown_lock_);
558
559 // The runtime is starting to shutdown but is blocked waiting on shutdown_cond_.
560 bool shutting_down_started_ GUARDED_BY(Locks::runtime_shutdown_lock_);
561
Elliott Hughesdcc24742011-09-07 14:02:44 -0700562 bool started_;
563
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700564 // New flag added which tells us if the runtime has finished starting. If
565 // this flag is set then the Daemon threads are created and the class loader
566 // is created. This flag is needed for knowing if its safe to request CMS.
567 bool finished_starting_;
568
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700569 // Hooks supported by JNI_CreateJavaVM
570 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
571 void (*exit_)(jint status);
572 void (*abort_)();
573
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700574 bool stats_enabled_;
575 RuntimeStats stats_;
576
Dave Allison0aded082013-11-07 13:15:11 -0800577 // Runtime profile support.
578 bool profile_;
579 std::string profile_output_filename_;
580 uint32_t profile_period_s_; // Generate profile every n seconds.
581 uint32_t profile_duration_s_; // Run profile for n seconds.
582 uint32_t profile_interval_us_; // Microseconds between samples.
583 double profile_backoff_coefficient_; // Coefficient to exponential backoff.
584
jeffhaob5e81852012-03-12 11:15:45 -0700585 bool method_trace_;
586 std::string method_trace_file_;
587 size_t method_trace_file_size_;
Ian Rogers62d6c772013-02-27 08:32:07 -0800588 instrumentation::Instrumentation instrumentation_;
jeffhao2692b572011-12-16 15:42:28 -0800589
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700590 typedef SafeMap<jobject, std::vector<const DexFile*>, JobjectComparator> CompileTimeClassPaths;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800591 CompileTimeClassPaths compile_time_class_paths_;
592 bool use_compile_time_class_path_;
Elliott Hughes131aef82012-01-27 11:53:35 -0800593
Ian Rogers365c1022012-06-22 15:05:28 -0700594 jobject main_thread_group_;
595 jobject system_thread_group_;
596
Brian Carlstromce888532013-10-10 00:32:58 -0700597 // As returned by ClassLoader.getSystemClassLoader().
598 jobject system_class_loader_;
599
Hiroshi Yamauchi2e899a92013-11-22 16:50:12 -0800600 // If true, then we dump the GC cumulative timings on shutdown.
601 bool dump_gc_performance_on_shutdown_;
602
Carl Shapiro61e019d2011-07-14 16:53:09 -0700603 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700604};
605
606} // namespace art
607
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700608#endif // ART_RUNTIME_RUNTIME_H_