blob: 2b3f10041120eba9cb9b57d5588e1a0b1fb8f30a [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"
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080037#include "object_callbacks.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;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010049 class Array;
Jeff Hao88474b42013-10-23 16:24:40 -070050 template<class T> class ObjectArray;
Ian Rogers1d54e732013-05-02 21:10:01 -070051 template<class T> class PrimitiveArray;
52 typedef PrimitiveArray<int8_t> ByteArray;
53 class String;
54 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080055} // namespace mirror
Mathieu Chartierc528dba2013-11-26 12:00:11 -080056namespace verifier {
57class MethodVerifier;
58}
Carl Shapiro61e019d2011-07-14 16:53:09 -070059class ClassLinker;
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000060class CompilerCallbacks;
Carl Shapirofc322c72011-07-27 00:20:01 -070061class DexFile;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070062class InternTable;
Ian Rogersb48b9eb2014-02-28 16:20:21 -080063class JavaVMExt;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070064class MonitorList;
Ian Rogersef7d42f2014-01-06 12:55:46 -080065class MonitorPool;
Elliott Hughese27955c2011-08-26 15:21:24 -070066class SignalCatcher;
Carl Shapiro61e019d2011-07-14 16:53:09 -070067class ThreadList;
jeffhao2692b572011-12-16 15:42:28 -080068class Trace;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010069class Transaction;
Carl Shapiro61e019d2011-07-14 16:53:09 -070070
Carl Shapiro1fb86202011-06-27 17:43:13 -070071class Runtime {
72 public:
Elliott Hughesf1a5adc2012-02-10 18:09:35 -080073 typedef std::vector<std::pair<std::string, const void*> > Options;
Brian Carlstrom8a436592011-08-15 21:27:23 -070074
Carl Shapiro61e019d2011-07-14 16:53:09 -070075 // Creates and initializes a new runtime.
Ian Rogers00f7d0e2012-07-19 15:28:27 -070076 static bool Create(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -070077 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070078
Elliott Hughesd9c67be2012-02-02 19:54:06 -080079 bool IsCompiler() const {
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000080 return compiler_callbacks_ != nullptr;
81 }
82
83 CompilerCallbacks* GetCompilerCallbacks() {
84 return compiler_callbacks_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -080085 }
86
Brian Carlstromcaabb1b2011-10-11 18:09:13 -070087 bool IsZygote() const {
88 return is_zygote_;
89 }
90
Anwar Ghuloum87183592013-08-14 12:12:19 -070091 bool IsExplicitGcDisabled() const {
92 return is_explicit_gc_disabled_;
93 }
94
Brian Carlstrom6449c622014-02-10 23:48:36 -080095 const std::vector<std::string>& GetCompilerOptions() const {
96 return compiler_options_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -070097 }
98
Brian Carlstrom6449c622014-02-10 23:48:36 -080099 const std::vector<std::string>& GetImageCompilerOptions() const {
100 return image_compiler_options_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700101 }
102
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700103 // Starts a runtime, which may cause threads to be started and code to run.
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700104 bool Start() UNLOCK_FUNCTION(Locks::mutator_lock_);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700105
Mathieu Chartier590fee92013-09-13 13:46:47 -0700106 bool IsShuttingDown(Thread* self);
107 bool IsShuttingDownLocked() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700108 return shutting_down_;
109 }
110
Ian Rogers120f1c72012-09-28 17:17:10 -0700111 size_t NumberOfThreadsBeingBorn() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
112 return threads_being_born_;
113 }
114
115 void StartThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
116 threads_being_born_++;
117 }
118
119 void EndThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
120
Ian Rogers9af209c2012-06-03 20:50:30 -0700121 bool IsStarted() const {
122 return started_;
123 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700124
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700125 bool IsFinishedStarting() const {
126 return finished_starting_;
127 }
128
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700129 static Runtime* Current() {
130 return instance_;
131 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700132
Elliott Hughesffe67362011-07-17 12:09:27 -0700133 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most
134 // callers should prefer.
135 // This isn't marked ((noreturn)) because then gcc will merge multiple calls
136 // in a single function together. This reduces code size slightly, but means
137 // that the native stack trace we get may point at the wrong call site.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700138 static void Abort() LOCKS_EXCLUDED(Locks::abort_lock_);
Elliott Hughesffe67362011-07-17 12:09:27 -0700139
Ian Rogers365c1022012-06-22 15:05:28 -0700140 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700141 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700142
143 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700144 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700145
Brian Carlstromce888532013-10-10 00:32:58 -0700146 // Returns the system ClassLoader which represents the CLASSPATH.
147 jobject GetSystemClassLoader() const;
148
Elliott Hughes462c9442012-03-23 18:47:50 -0700149 // Attaches the calling native thread to the runtime.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800150 bool AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
151 bool create_peer);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700152
Elliott Hughesbf86d042011-08-31 17:53:14 -0700153 void CallExitHook(jint status);
154
Carl Shapiro61e019d2011-07-14 16:53:09 -0700155 // Detaches the current native thread from the runtime.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700156 void DetachCurrentThread() LOCKS_EXCLUDED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700157
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700158 void DumpForSigQuit(std::ostream& os)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700159 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800160 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700161
Carl Shapiro61e019d2011-07-14 16:53:09 -0700162 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700163
Brian Carlstroma004aa92012-02-08 18:05:09 -0800164 const std::string& GetBootClassPathString() const {
165 return boot_class_path_string_;
166 }
167
168 const std::string& GetClassPathString() const {
169 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700170 }
171
172 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700173 return class_linker_;
174 }
175
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700176 size_t GetDefaultStackSize() const {
177 return default_stack_size_;
178 }
179
Ian Rogers1d54e732013-05-02 21:10:01 -0700180 gc::Heap* GetHeap() const {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800181 return heap_;
182 }
183
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700184 InternTable* GetInternTable() const {
Brian Carlstrome8104522013-10-15 21:56:36 -0700185 DCHECK(intern_table_ != NULL);
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700186 return intern_table_;
187 }
188
Elliott Hughes0af55432011-08-17 18:37:28 -0700189 JavaVMExt* GetJavaVM() const {
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700190 return java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700191 }
192
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700193 size_t GetMaxSpinsBeforeThinkLockInflation() const {
194 return max_spins_before_thin_lock_inflation_;
195 }
196
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700197 MonitorList* GetMonitorList() const {
198 return monitor_list_;
199 }
200
Ian Rogersef7d42f2014-01-06 12:55:46 -0800201 MonitorPool* GetMonitorPool() const {
202 return monitor_pool_;
203 }
204
Ian Rogersa436fde2013-08-27 23:34:06 -0700205 mirror::Throwable* GetPreAllocatedOutOfMemoryError() const
206 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes225f5a12012-06-11 11:23:48 -0700207
208 const std::vector<std::string>& GetProperties() const {
209 return properties_;
210 }
211
Elliott Hughesd92bec42011-09-02 17:04:36 -0700212 ThreadList* GetThreadList() const {
213 return thread_list_;
214 }
215
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800216 static const char* GetVersion() {
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700217 return "2.0.0";
218 }
219
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700220 void DisallowNewSystemWeaks() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
221 void AllowNewSystemWeaks() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
222
Ian Rogers1d54e732013-05-02 21:10:01 -0700223 // Visit all the roots. If only_dirty is true then non-dirty roots won't be visited. If
224 // clean_dirty is true then dirty roots will be marked as non-dirty after visiting.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800225 void VisitRoots(RootCallback* visitor, void* arg, bool only_dirty, bool clean_dirty)
Ian Rogers1d54e732013-05-02 21:10:01 -0700226 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700227
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700228 // Visit all of the roots we can do safely do concurrently.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800229 void VisitConcurrentRoots(RootCallback* visitor, void* arg, bool only_dirty, bool clean_dirty)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800230 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700231
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700232 // Visit all of the non thread roots, we can do this with mutators unpaused.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800233 void VisitNonThreadRoots(RootCallback* visitor, void* arg)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800234 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700235
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700236 // Visit all other roots which must be done with mutators suspended.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800237 void VisitNonConcurrentRoots(RootCallback* visitor, void* arg)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800238 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700239
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700240 // Sweep system weaks, the system weak is deleted if the visitor return nullptr. Otherwise, the
241 // system weak is updated to be the visitor's returned value.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800242 void SweepSystemWeaks(IsMarkedCallback* visitor, void* arg)
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700243 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700244
Ian Rogers9af209c2012-06-03 20:50:30 -0700245 // Returns a special method that calls into a trampoline for runtime method resolution
Brian Carlstromea46f952013-07-30 01:26:50 -0700246 mirror::ArtMethod* GetResolutionMethod() const {
Ian Rogers9af209c2012-06-03 20:50:30 -0700247 CHECK(HasResolutionMethod());
248 return resolution_method_;
249 }
250
251 bool HasResolutionMethod() const {
252 return resolution_method_ != NULL;
253 }
254
Brian Carlstromea46f952013-07-30 01:26:50 -0700255 void SetResolutionMethod(mirror::ArtMethod* method) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700256 resolution_method_ = method;
257 }
258
Brian Carlstromea46f952013-07-30 01:26:50 -0700259 mirror::ArtMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800260
Jeff Hao88474b42013-10-23 16:24:40 -0700261 // Returns a special method that calls into a trampoline for runtime imt conflicts
262 mirror::ArtMethod* GetImtConflictMethod() const {
263 CHECK(HasImtConflictMethod());
264 return imt_conflict_method_;
265 }
266
267 bool HasImtConflictMethod() const {
268 return imt_conflict_method_ != NULL;
269 }
270
271 void SetImtConflictMethod(mirror::ArtMethod* method) {
272 imt_conflict_method_ = method;
273 }
274
275 mirror::ArtMethod* CreateImtConflictMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
276
277 // Returns an imt with every entry set to conflict, used as default imt for all classes.
278 mirror::ObjectArray<mirror::ArtMethod>* GetDefaultImt() const {
279 CHECK(HasDefaultImt());
280 return default_imt_;
281 }
282
283 bool HasDefaultImt() const {
284 return default_imt_ != NULL;
285 }
286
287 void SetDefaultImt(mirror::ObjectArray<mirror::ArtMethod>* imt) {
288 default_imt_ = imt;
289 }
290
291 mirror::ObjectArray<mirror::ArtMethod>* CreateDefaultImt(ClassLinker* cl)
292 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
293
Ian Rogersff1ed472011-09-20 13:46:24 -0700294 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700295 enum CalleeSaveType {
296 kSaveAll,
297 kRefsOnly,
298 kRefsAndArgs,
299 kLastCalleeSaveType // Value used for iteration
300 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700301
302 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Elliott Hughes225f5a12012-06-11 11:23:48 -0700303 return callee_save_methods_[type] != NULL;
Ian Rogers9af209c2012-06-03 20:50:30 -0700304 }
305
Brian Carlstromea46f952013-07-30 01:26:50 -0700306 mirror::ArtMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
Ian Rogersdf1ce912012-11-27 17:07:11 -0800307 DCHECK(HasCalleeSaveMethod(type));
Elliott Hughes225f5a12012-06-11 11:23:48 -0700308 return callee_save_methods_[type];
Ian Rogers9af209c2012-06-03 20:50:30 -0700309 }
310
Ian Rogers936b37f2014-02-14 00:52:24 -0800311 static size_t GetCalleeSaveMethodOffset(CalleeSaveType type) {
312 return OFFSETOF_MEMBER(Runtime, callee_save_methods_[type]);
313 }
314
Brian Carlstromea46f952013-07-30 01:26:50 -0700315 void SetCalleeSaveMethod(mirror::ArtMethod* method, CalleeSaveType type);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700316
Brian Carlstromea46f952013-07-30 01:26:50 -0700317 mirror::ArtMethod* CreateCalleeSaveMethod(InstructionSet instruction_set,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800318 CalleeSaveType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700319 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700320
Brian Carlstromea46f952013-07-30 01:26:50 -0700321 mirror::ArtMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700322 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700323
Brian Carlstromea46f952013-07-30 01:26:50 -0700324 mirror::ArtMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersff1ed472011-09-20 13:46:24 -0700326
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700327 int32_t GetStat(int kind);
328
Ian Rogers9af209c2012-06-03 20:50:30 -0700329 RuntimeStats* GetStats() {
330 return &stats_;
331 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700332
333 bool HasStatsEnabled() const {
334 return stats_enabled_;
335 }
336
337 void ResetStats(int kinds);
338
339 void SetStatsEnabled(bool new_state);
340
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700341 bool PreZygoteFork();
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700342 bool InitZygote();
343 void DidForkFromZygote();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700344
Ian Rogers62d6c772013-02-27 08:32:07 -0800345 instrumentation::Instrumentation* GetInstrumentation() {
346 return &instrumentation_;
347 }
jeffhao2692b572011-12-16 15:42:28 -0800348
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800349 bool UseCompileTimeClassPath() const {
350 return use_compile_time_class_path_;
351 }
Ian Rogers9af209c2012-06-03 20:50:30 -0700352
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800353 void AddMethodVerifier(verifier::MethodVerifier* verifier) LOCKS_EXCLUDED(method_verifier_lock_);
354 void RemoveMethodVerifier(verifier::MethodVerifier* verifier)
355 LOCKS_EXCLUDED(method_verifier_lock_);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800356
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700357 const std::vector<const DexFile*>& GetCompileTimeClassPath(jobject class_loader);
358 void SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800359
Dave Allison0aded082013-11-07 13:15:11 -0800360 void StartProfiler(const char *appDir, bool startImmediately = false);
361
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100362 // Transaction support.
363 bool IsActiveTransaction() const;
364 void EnterTransactionMode(Transaction* transaction);
365 void ExitTransactionMode();
366 void RecordWriteField32(mirror::Object* obj, MemberOffset field_offset, uint32_t value,
367 bool is_volatile) const;
368 void RecordWriteField64(mirror::Object* obj, MemberOffset field_offset, uint64_t value,
369 bool is_volatile) const;
370 void RecordWriteFieldReference(mirror::Object* obj, MemberOffset field_offset,
371 mirror::Object* value, bool is_volatile) const;
372 void RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) const
373 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
374 void RecordStrongStringInsertion(mirror::String* s, uint32_t hash_code) const
375 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
376 void RecordWeakStringInsertion(mirror::String* s, uint32_t hash_code) const
377 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
378 void RecordStrongStringRemoval(mirror::String* s, uint32_t hash_code) const
379 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
380 void RecordWeakStringRemoval(mirror::String* s, uint32_t hash_code) const
381 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
382
Mathieu Chartier15d34022014-02-26 17:16:38 -0800383 void SetFaultMessage(const std::string& message);
384 // Only read by the signal handler, NO_THREAD_SAFETY_ANALYSIS to prevent lock order violations
385 // with the unexpected_signal_lock_.
386 const std::string& GetFaultMessage() NO_THREAD_SAFETY_ANALYSIS {
387 return fault_message_;
388 }
389
Carl Shapirob5573532011-07-12 18:22:59 -0700390 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700391 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700392
Elliott Hughesdcc24742011-09-07 14:02:44 -0700393 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700394
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700395 void BlockSignals();
396
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700397 bool Init(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700398 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
399 void InitNativeMethods() LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers365c1022012-06-22 15:05:28 -0700400 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800401 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700402
Elliott Hughes85d15452011-09-16 17:33:01 -0700403 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700404 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700405
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800406 // A pointer to the active runtime or NULL.
407 static Runtime* instance_;
408
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000409 CompilerCallbacks* compiler_callbacks_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700410 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700411 bool is_concurrent_gc_enabled_;
Anwar Ghuloum87183592013-08-14 12:12:19 -0700412 bool is_explicit_gc_disabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700413
Brian Carlstrom6449c622014-02-10 23:48:36 -0800414 std::vector<std::string> compiler_options_;
415 std::vector<std::string> image_compiler_options_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700416
Brian Carlstroma004aa92012-02-08 18:05:09 -0800417 std::string boot_class_path_string_;
418 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700419 std::vector<std::string> properties_;
420
Brian Carlstromb765be02011-08-17 23:54:10 -0700421 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700422 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700423
Ian Rogers1d54e732013-05-02 21:10:01 -0700424 gc::Heap* heap_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800425
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700426 // The number of spins that are done before thread suspension is used to forcibly inflate.
427 size_t max_spins_before_thin_lock_inflation_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700428 MonitorList* monitor_list_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800429 MonitorPool* monitor_pool_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700430
Carl Shapirob5573532011-07-12 18:22:59 -0700431 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700432
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700433 InternTable* intern_table_;
434
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700435 ClassLinker* class_linker_;
436
Elliott Hughese27955c2011-08-26 15:21:24 -0700437 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700438 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700439
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700440 JavaVMExt* java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700441
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800442 mirror::Throwable* pre_allocated_OutOfMemoryError_;
Elliott Hughes225f5a12012-06-11 11:23:48 -0700443
Brian Carlstromea46f952013-07-30 01:26:50 -0700444 mirror::ArtMethod* callee_save_methods_[kLastCalleeSaveType];
Ian Rogersff1ed472011-09-20 13:46:24 -0700445
Brian Carlstromea46f952013-07-30 01:26:50 -0700446 mirror::ArtMethod* resolution_method_;
Ian Rogers19846512012-02-24 11:42:47 -0800447
Jeff Hao88474b42013-10-23 16:24:40 -0700448 mirror::ArtMethod* imt_conflict_method_;
449
450 mirror::ObjectArray<mirror::ArtMethod>* default_imt_;
451
Mathieu Chartier15d34022014-02-26 17:16:38 -0800452 // Fault message, printed when we get a SIGSEGV.
453 Mutex fault_message_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
454 std::string fault_message_ GUARDED_BY(fault_message_lock_);
455
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800456 // Method verifier set, used so that we can update their GC roots.
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800457 Mutex method_verifiers_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800458 std::set<verifier::MethodVerifier*> method_verifiers_;
459
Ian Rogers120f1c72012-09-28 17:17:10 -0700460 // A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
461 // the shutdown lock so that threads aren't born while we're shutting down.
462 size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
463
464 // Waited upon until no threads are being born.
465 UniquePtr<ConditionVariable> shutdown_cond_ GUARDED_BY(Locks::runtime_shutdown_lock_);
466
467 // Set when runtime shutdown is past the point that new threads may attach.
468 bool shutting_down_ GUARDED_BY(Locks::runtime_shutdown_lock_);
469
470 // The runtime is starting to shutdown but is blocked waiting on shutdown_cond_.
471 bool shutting_down_started_ GUARDED_BY(Locks::runtime_shutdown_lock_);
472
Elliott Hughesdcc24742011-09-07 14:02:44 -0700473 bool started_;
474
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700475 // New flag added which tells us if the runtime has finished starting. If
476 // this flag is set then the Daemon threads are created and the class loader
477 // is created. This flag is needed for knowing if its safe to request CMS.
478 bool finished_starting_;
479
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700480 // Hooks supported by JNI_CreateJavaVM
481 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
482 void (*exit_)(jint status);
483 void (*abort_)();
484
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700485 bool stats_enabled_;
486 RuntimeStats stats_;
487
Dave Allison0aded082013-11-07 13:15:11 -0800488 // Runtime profile support.
489 bool profile_;
490 std::string profile_output_filename_;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800491 uint32_t profile_period_s_; // Generate profile every n seconds.
492 uint32_t profile_duration_s_; // Run profile for n seconds.
493 uint32_t profile_interval_us_; // Microseconds between samples.
Dave Allison0aded082013-11-07 13:15:11 -0800494 double profile_backoff_coefficient_; // Coefficient to exponential backoff.
495
jeffhaob5e81852012-03-12 11:15:45 -0700496 bool method_trace_;
497 std::string method_trace_file_;
498 size_t method_trace_file_size_;
Ian Rogers62d6c772013-02-27 08:32:07 -0800499 instrumentation::Instrumentation instrumentation_;
jeffhao2692b572011-12-16 15:42:28 -0800500
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700501 typedef SafeMap<jobject, std::vector<const DexFile*>, JobjectComparator> CompileTimeClassPaths;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800502 CompileTimeClassPaths compile_time_class_paths_;
503 bool use_compile_time_class_path_;
Elliott Hughes131aef82012-01-27 11:53:35 -0800504
Ian Rogers365c1022012-06-22 15:05:28 -0700505 jobject main_thread_group_;
506 jobject system_thread_group_;
507
Brian Carlstromce888532013-10-10 00:32:58 -0700508 // As returned by ClassLoader.getSystemClassLoader().
509 jobject system_class_loader_;
510
Hiroshi Yamauchi2e899a92013-11-22 16:50:12 -0800511 // If true, then we dump the GC cumulative timings on shutdown.
512 bool dump_gc_performance_on_shutdown_;
513
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100514 // Transaction used for pre-initializing classes at compilation time.
515 Transaction* preinitialization_transaction;
516
Carl Shapiro61e019d2011-07-14 16:53:09 -0700517 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700518};
519
520} // namespace art
521
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700522#endif // ART_RUNTIME_RUNTIME_H_