blob: 58f985fae72328c377f5242f95abc1d09fb14804 [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"
Ian Rogers1d54e732013-05-02 21:10:01 -070030#include "gc/heap.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070031#include "globals.h"
Elliott Hughes0f3c5532012-03-30 14:51:51 -070032#include "instruction_set.h"
Ian Rogers62d6c772013-02-27 08:32:07 -080033#include "instrumentation.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070034#include "jobject_comparator.h"
Ian Rogers120f1c72012-09-28 17:17:10 -070035#include "locks.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080036#include "root_visitor.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070037#include "runtime_stats.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070038#include "safe_map.h"
Carl Shapirob5573532011-07-12 18:22:59 -070039
Carl Shapiro1fb86202011-06-27 17:43:13 -070040namespace art {
41
Ian Rogers1d54e732013-05-02 21:10:01 -070042namespace gc {
43 class Heap;
44}
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080045namespace mirror {
Ian Rogers1d54e732013-05-02 21:10:01 -070046 class AbstractMethod;
47 class ClassLoader;
48 template<class T> class PrimitiveArray;
49 typedef PrimitiveArray<int8_t> ByteArray;
50 class String;
51 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080052} // namespace mirror
Carl Shapiro61e019d2011-07-14 16:53:09 -070053class ClassLinker;
Carl Shapirofc322c72011-07-27 00:20:01 -070054class DexFile;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070055class InternTable;
Ian Rogers1b09b092012-08-20 15:35:52 -070056struct JavaVMExt;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070057class MonitorList;
Elliott Hughese27955c2011-08-26 15:21:24 -070058class SignalCatcher;
Carl Shapiro61e019d2011-07-14 16:53:09 -070059class ThreadList;
jeffhao2692b572011-12-16 15:42:28 -080060class Trace;
Carl Shapiro61e019d2011-07-14 16:53:09 -070061
Carl Shapiro1fb86202011-06-27 17:43:13 -070062class Runtime {
63 public:
Elliott Hughesf1a5adc2012-02-10 18:09:35 -080064 typedef std::vector<std::pair<std::string, const void*> > Options;
Brian Carlstrom8a436592011-08-15 21:27:23 -070065
Elliott Hughes2010a602013-07-02 14:17:23 -070066 // In small mode, apps with fewer than this number of methods will be compiled
Anwar Ghuloumc44f68f2013-05-10 13:24:54 -070067 // anyways.
Anwar Ghuloum97543682013-06-14 12:58:16 -070068 // TODO: come up with a reasonable default.
Anwar Ghuloumc44f68f2013-05-10 13:24:54 -070069 static const size_t kDefaultSmallModeMethodThreshold = 0;
70
71 // In small mode, methods smaller than this dex op count limit will get compiled
72 // anyways.
Anwar Ghuloum97543682013-06-14 12:58:16 -070073 // TODO: come up with a reasonable default.
74 static const size_t kDefaultSmallModeMethodDexSizeLimit = 300;
Anwar Ghuloum8447d842013-04-30 17:27:40 -070075
Brian Carlstrom8a436592011-08-15 21:27:23 -070076 class ParsedOptions {
77 public:
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070078 // returns null if problem parsing and ignore_unrecognized is false
79 static ParsedOptions* Create(const Options& options, bool ignore_unrecognized);
Brian Carlstrom8a436592011-08-15 21:27:23 -070080
Brian Carlstroma004aa92012-02-08 18:05:09 -080081 const std::vector<const DexFile*>* boot_class_path_;
82 std::string boot_class_path_string_;
83 std::string class_path_string_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -070084 std::string host_prefix_;
Brian Carlstrom223f20f2012-02-04 23:06:55 -080085 std::string image_;
Elliott Hughes515a5bc2011-08-17 11:08:34 -070086 bool check_jni_;
Elliott Hughesa0957642011-09-02 14:27:33 -070087 std::string jni_trace_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -080088 bool is_compiler_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -070089 bool is_zygote_;
Ian Rogers50ffee22012-11-20 11:47:44 -080090 bool interpreter_only_;
Mathieu Chartier069387a2012-06-18 12:01:01 -070091 bool is_concurrent_gc_enabled_;
Brian Carlstrom8a436592011-08-15 21:27:23 -070092 size_t heap_initial_size_;
93 size_t heap_maximum_size_;
jeffhaoc1160702011-10-27 15:48:45 -070094 size_t heap_growth_limit_;
Mathieu Chartier0051be62012-10-12 17:47:11 -070095 size_t heap_min_free_;
96 size_t heap_max_free_;
97 double heap_target_utilization_;
Brian Carlstromf734cf52011-08-17 16:28:14 -070098 size_t stack_size_;
Elliott Hughesbb1e8f02011-10-18 14:14:25 -070099 size_t lock_profiling_threshold_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700100 std::string stack_trace_file_;
jeffhaob5e81852012-03-12 11:15:45 -0700101 bool method_trace_;
102 std::string method_trace_file_;
103 size_t method_trace_file_size_;
Elliott Hughesfc861622011-10-17 17:57:47 -0700104 bool (*hook_is_sensitive_thread_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700105 jint (*hook_vfprintf_)(FILE* stream, const char* format, va_list ap);
106 void (*hook_exit_)(jint status);
107 void (*hook_abort_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700108 std::vector<std::string> properties_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700109 bool small_mode_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700110
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700111 size_t small_mode_method_threshold_;
112 size_t small_mode_method_dex_size_limit_;
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700113
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700114 bool sea_ir_mode_;
115
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700116 private:
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700117 ParsedOptions() {}
Brian Carlstrom8a436592011-08-15 21:27:23 -0700118 };
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700119
Carl Shapiro61e019d2011-07-14 16:53:09 -0700120 // Creates and initializes a new runtime.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700121 static bool Create(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700122 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700123
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800124 bool IsCompiler() const {
125 return is_compiler_;
126 }
127
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700128 bool IsZygote() const {
129 return is_zygote_;
130 }
131
Mathieu Chartier069387a2012-06-18 12:01:01 -0700132 bool IsConcurrentGcEnabled() const {
133 return is_concurrent_gc_enabled_;
134 }
135
Brian Carlstrom51c24672013-07-11 16:00:56 -0700136#ifdef ART_SEA_IR_MODE
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700137 bool IsSeaIRMode() const {
138 return sea_ir_mode_;
139 }
Brian Carlstrom51c24672013-07-11 16:00:56 -0700140#endif
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700141
142 void SetSeaIRMode(bool sea_ir_mode) {
143 sea_ir_mode_ = sea_ir_mode;
144 }
145
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700146 bool IsSmallMode() const {
147 return small_mode_;
148 }
149
150
151 void SetSmallMode(bool small_mode) {
152 small_mode_ = small_mode;
153 }
154
155 size_t GetSmallModeMethodThreshold() const {
156 return small_mode_method_threshold_;
157 }
158
159 size_t GetSmallModeMethodDexSizeLimit() const {
160 return small_mode_method_dex_size_limit_;
161 }
162
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700163 const std::string& GetHostPrefix() const {
Elliott Hughes307f75d2011-10-12 18:04:40 -0700164 DCHECK(!IsStarted());
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700165 return host_prefix_;
166 }
167
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700168 // Starts a runtime, which may cause threads to be started and code to run.
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700169 bool Start() UNLOCK_FUNCTION(Locks::mutator_lock_);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700170
Ian Rogers120f1c72012-09-28 17:17:10 -0700171 bool IsShuttingDown() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700172 return shutting_down_;
173 }
174
Ian Rogers120f1c72012-09-28 17:17:10 -0700175 size_t NumberOfThreadsBeingBorn() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
176 return threads_being_born_;
177 }
178
179 void StartThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
180 threads_being_born_++;
181 }
182
183 void EndThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
184
Ian Rogers9af209c2012-06-03 20:50:30 -0700185 bool IsStarted() const {
186 return started_;
187 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700188
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700189 bool IsFinishedStarting() const {
190 return finished_starting_;
191 }
192
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700193 static Runtime* Current() {
194 return instance_;
195 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700196
Elliott Hughesffe67362011-07-17 12:09:27 -0700197 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most
198 // callers should prefer.
199 // This isn't marked ((noreturn)) because then gcc will merge multiple calls
200 // in a single function together. This reduces code size slightly, but means
201 // that the native stack trace we get may point at the wrong call site.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700202 static void Abort() LOCKS_EXCLUDED(Locks::abort_lock_);
Elliott Hughesffe67362011-07-17 12:09:27 -0700203
Ian Rogers365c1022012-06-22 15:05:28 -0700204 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700205 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700206
207 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700208 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700209
Elliott Hughes462c9442012-03-23 18:47:50 -0700210 // Attaches the calling native thread to the runtime.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800211 bool AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
212 bool create_peer);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700213
Elliott Hughesbf86d042011-08-31 17:53:14 -0700214 void CallExitHook(jint status);
215
Carl Shapiro61e019d2011-07-14 16:53:09 -0700216 // Detaches the current native thread from the runtime.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700217 void DetachCurrentThread() LOCKS_EXCLUDED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700218
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700219 void DumpForSigQuit(std::ostream& os)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700220 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800221 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700222
Carl Shapiro61e019d2011-07-14 16:53:09 -0700223 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700224
Brian Carlstroma004aa92012-02-08 18:05:09 -0800225 const std::string& GetBootClassPathString() const {
226 return boot_class_path_string_;
227 }
228
229 const std::string& GetClassPathString() const {
230 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700231 }
232
233 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700234 return class_linker_;
235 }
236
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700237 size_t GetDefaultStackSize() const {
238 return default_stack_size_;
239 }
240
Ian Rogers1d54e732013-05-02 21:10:01 -0700241 gc::Heap* GetHeap() const {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800242 return heap_;
243 }
244
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700245 InternTable* GetInternTable() const {
246 return intern_table_;
247 }
248
Elliott Hughes0af55432011-08-17 18:37:28 -0700249 JavaVMExt* GetJavaVM() const {
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700250 return java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700251 }
252
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700253 MonitorList* GetMonitorList() const {
254 return monitor_list_;
255 }
256
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800257 mirror::Throwable* GetPreAllocatedOutOfMemoryError() {
Elliott Hughes225f5a12012-06-11 11:23:48 -0700258 return pre_allocated_OutOfMemoryError_;
259 }
260
261 const std::vector<std::string>& GetProperties() const {
262 return properties_;
263 }
264
Elliott Hughesd92bec42011-09-02 17:04:36 -0700265 ThreadList* GetThreadList() const {
266 return thread_list_;
267 }
268
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700269 const char* GetVersion() const {
270 return "2.0.0";
271 }
272
Ian Rogers1d54e732013-05-02 21:10:01 -0700273 // Visit all the roots. If only_dirty is true then non-dirty roots won't be visited. If
274 // clean_dirty is true then dirty roots will be marked as non-dirty after visiting.
275 void VisitRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool clean_dirty)
276 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700277
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700278 // Visit all of the roots we can do safely do concurrently.
Ian Rogers1d54e732013-05-02 21:10:01 -0700279 void VisitConcurrentRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool clean_dirty);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700280
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700281 // Visit all of the non thread roots, we can do this with mutators unpaused.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800282 void VisitNonThreadRoots(RootVisitor* visitor, void* arg);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700283
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700284 // Visit all other roots which must be done with mutators suspended.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800285 void VisitNonConcurrentRoots(RootVisitor* visitor, void* arg)
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700286 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
287
Ian Rogers9af209c2012-06-03 20:50:30 -0700288 // Returns a special method that calls into a trampoline for runtime method resolution
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800289 mirror::AbstractMethod* GetResolutionMethod() const {
Ian Rogers9af209c2012-06-03 20:50:30 -0700290 CHECK(HasResolutionMethod());
291 return resolution_method_;
292 }
293
294 bool HasResolutionMethod() const {
295 return resolution_method_ != NULL;
296 }
297
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800298 void SetResolutionMethod(mirror::AbstractMethod* method) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700299 resolution_method_ = method;
300 }
301
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800302 mirror::AbstractMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800303
Ian Rogersff1ed472011-09-20 13:46:24 -0700304 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700305 enum CalleeSaveType {
306 kSaveAll,
307 kRefsOnly,
308 kRefsAndArgs,
309 kLastCalleeSaveType // Value used for iteration
310 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700311
312 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Elliott Hughes225f5a12012-06-11 11:23:48 -0700313 return callee_save_methods_[type] != NULL;
Ian Rogers9af209c2012-06-03 20:50:30 -0700314 }
315
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800316 mirror::AbstractMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
Ian Rogersdf1ce912012-11-27 17:07:11 -0800317 DCHECK(HasCalleeSaveMethod(type));
Elliott Hughes225f5a12012-06-11 11:23:48 -0700318 return callee_save_methods_[type];
Ian Rogers9af209c2012-06-03 20:50:30 -0700319 }
320
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800321 void SetCalleeSaveMethod(mirror::AbstractMethod* method, CalleeSaveType type);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700322
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800323 mirror::AbstractMethod* CreateCalleeSaveMethod(InstructionSet instruction_set,
324 CalleeSaveType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700326
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800327 mirror::AbstractMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700328 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700329
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800330 mirror::AbstractMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700331 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersff1ed472011-09-20 13:46:24 -0700332
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700333 int32_t GetStat(int kind);
334
Ian Rogers9af209c2012-06-03 20:50:30 -0700335 RuntimeStats* GetStats() {
336 return &stats_;
337 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700338
339 bool HasStatsEnabled() const {
340 return stats_enabled_;
341 }
342
343 void ResetStats(int kinds);
344
345 void SetStatsEnabled(bool new_state);
346
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700347 bool PreZygoteFork();
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700348 bool InitZygote();
349 void DidForkFromZygote();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700350
Ian Rogers62d6c772013-02-27 08:32:07 -0800351 instrumentation::Instrumentation* GetInstrumentation() {
352 return &instrumentation_;
353 }
jeffhao2692b572011-12-16 15:42:28 -0800354
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800355 bool UseCompileTimeClassPath() const {
356 return use_compile_time_class_path_;
357 }
Ian Rogers9af209c2012-06-03 20:50:30 -0700358
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700359 const std::vector<const DexFile*>& GetCompileTimeClassPath(jobject class_loader);
360 void SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800361
Carl Shapirob5573532011-07-12 18:22:59 -0700362 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700363 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700364
Elliott Hughesdcc24742011-09-07 14:02:44 -0700365 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700366
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700367 void BlockSignals();
368
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700369 bool Init(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700370 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
371 void InitNativeMethods() LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers365c1022012-06-22 15:05:28 -0700372 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800373 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700374
Elliott Hughes85d15452011-09-16 17:33:01 -0700375 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700376 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700377
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800378 // A pointer to the active runtime or NULL.
379 static Runtime* instance_;
380
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800381 bool is_compiler_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700382 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700383 bool is_concurrent_gc_enabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700384
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700385 bool small_mode_;
386 size_t small_mode_method_threshold_;
387 size_t small_mode_method_dex_size_limit_;
388
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700389 bool sea_ir_mode_;
390
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700391 // The host prefix is used during cross compilation. It is removed
392 // from the start of host paths such as:
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800393 // $ANDROID_PRODUCT_OUT/system/framework/boot.oat
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700394 // to produce target paths such as
Brian Carlstrom47a0d5a2011-10-12 21:20:05 -0700395 // /system/framework/boot.oat
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700396 // Similarly it is prepended to target paths to arrive back at a
397 // host past. In both cases this is necessary because image and oat
398 // files embedded expect paths of dependent files (an image points
399 // to an oat file and an oat files to one or more dex files). These
400 // files contain the expected target path.
401 std::string host_prefix_;
402
Brian Carlstroma004aa92012-02-08 18:05:09 -0800403 std::string boot_class_path_string_;
404 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700405 std::vector<std::string> properties_;
406
Brian Carlstromb765be02011-08-17 23:54:10 -0700407 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700408 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700409
Ian Rogers1d54e732013-05-02 21:10:01 -0700410 gc::Heap* heap_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800411
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700412 MonitorList* monitor_list_;
413
Carl Shapirob5573532011-07-12 18:22:59 -0700414 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700415
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700416 InternTable* intern_table_;
417
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700418 ClassLinker* class_linker_;
419
Elliott Hughese27955c2011-08-26 15:21:24 -0700420 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700421 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700422
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700423 JavaVMExt* java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700424
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800425 mirror::Throwable* pre_allocated_OutOfMemoryError_;
Elliott Hughes225f5a12012-06-11 11:23:48 -0700426
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800427 mirror::AbstractMethod* callee_save_methods_[kLastCalleeSaveType];
Ian Rogersff1ed472011-09-20 13:46:24 -0700428
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800429 mirror::AbstractMethod* resolution_method_;
Ian Rogers19846512012-02-24 11:42:47 -0800430
Brian Carlstromaded5f72011-10-07 17:15:04 -0700431 // As returned by ClassLoader.getSystemClassLoader()
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800432 mirror::ClassLoader* system_class_loader_;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700433
Ian Rogers120f1c72012-09-28 17:17:10 -0700434 // A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
435 // the shutdown lock so that threads aren't born while we're shutting down.
436 size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
437
438 // Waited upon until no threads are being born.
439 UniquePtr<ConditionVariable> shutdown_cond_ GUARDED_BY(Locks::runtime_shutdown_lock_);
440
441 // Set when runtime shutdown is past the point that new threads may attach.
442 bool shutting_down_ GUARDED_BY(Locks::runtime_shutdown_lock_);
443
444 // The runtime is starting to shutdown but is blocked waiting on shutdown_cond_.
445 bool shutting_down_started_ GUARDED_BY(Locks::runtime_shutdown_lock_);
446
Elliott Hughesdcc24742011-09-07 14:02:44 -0700447 bool started_;
448
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700449 // New flag added which tells us if the runtime has finished starting. If
450 // this flag is set then the Daemon threads are created and the class loader
451 // is created. This flag is needed for knowing if its safe to request CMS.
452 bool finished_starting_;
453
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700454 // Hooks supported by JNI_CreateJavaVM
455 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
456 void (*exit_)(jint status);
457 void (*abort_)();
458
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700459 bool stats_enabled_;
460 RuntimeStats stats_;
461
jeffhaob5e81852012-03-12 11:15:45 -0700462 bool method_trace_;
463 std::string method_trace_file_;
464 size_t method_trace_file_size_;
Ian Rogers62d6c772013-02-27 08:32:07 -0800465 instrumentation::Instrumentation instrumentation_;
jeffhao2692b572011-12-16 15:42:28 -0800466
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700467 typedef SafeMap<jobject, std::vector<const DexFile*>, JobjectComparator> CompileTimeClassPaths;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800468 CompileTimeClassPaths compile_time_class_paths_;
469 bool use_compile_time_class_path_;
Elliott Hughes131aef82012-01-27 11:53:35 -0800470
Ian Rogers365c1022012-06-22 15:05:28 -0700471 jobject main_thread_group_;
472 jobject system_thread_group_;
473
Carl Shapiro61e019d2011-07-14 16:53:09 -0700474 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700475};
476
477} // namespace art
478
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700479#endif // ART_RUNTIME_RUNTIME_H_