vm/Globals.h

   1 /*
   2  * Copyright (C) 2008 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  */
  16
  17 /*
  18  * Variables with library scope.
  19  *
  20  * Prefer this over scattered static and global variables -- it's easier to
  21  * view the state in a debugger, it makes clean shutdown simpler, we can
  22  * trivially dump the state into a crash log, and it dodges most naming
  23  * collisions that will arise when we are embedded in a larger program.
  24  *
  25  * If we want multiple VMs per process, this can get stuffed into TLS (or
  26  * accessed through a Thread field).  May need to pass it around for some
  27  * of the early initialization functions.
  28  */
  29 #ifndef DALVIK_GLOBALS_H_
  30 #define DALVIK_GLOBALS_H_
  31
  32 #include <string>
  33 #include <vector>
  34
  35 #include <stdarg.h>
  36 #include <pthread.h>
  37
  38 /* private structures */
  39 struct GcHeap;
  40 struct BreakpointSet;
  41 struct InlineSub;
  42
  43 /*
  44  * One of these for each -ea/-da/-esa/-dsa on the command line.
  45  */
  46 struct AssertionControl {
  47     char*   pkgOrClass;         /* package/class string, or NULL for esa/dsa */
  48     int     pkgOrClassLen;      /* string length, for quick compare */
  49     bool    enable;             /* enable or disable */
  50     bool    isPackage;          /* string ended with "..."? */
  51 };
  52
  53 /*
  54  * Register map generation mode.  Only applicable when generateRegisterMaps
  55  * is enabled.  (The "disabled" state is not folded into this because
  56  * there are callers like dexopt that want to enable/disable without
  57  * specifying the configuration details.)
  58  *
  59  * "TypePrecise" is slower and requires additional storage for the register
  60  * maps, but allows type-precise GC.  "LivePrecise" is even slower and
  61  * requires additional heap during processing, but allows live-precise GC.
  62  */
  63 enum RegisterMapMode {
  64     kRegisterMapModeUnknown = 0,
  65     kRegisterMapModeTypePrecise,
  66     kRegisterMapModeLivePrecise
  67 };
  68
  69 /*
  70  * Profiler clock source.
  71  */
  72 enum ProfilerClockSource {
  73     kProfilerClockSourceThreadCpu,
  74     kProfilerClockSourceWall,
  75     kProfilerClockSourceDual,
  76 };
  77
  78 /*
  79  * All fields are initialized to zero.
  80  *
  81  * Storage allocated here must be freed by a subsystem shutdown function.
  82  */
  83 struct DvmGlobals {
  84     /*
  85      * Some options from the command line or environment.
  86      */
  87     char*       bootClassPathStr;
  88     char*       classPathStr;
  89
  90     size_t      heapStartingSize;
  91     size_t      heapMaximumSize;
  92     size_t      heapGrowthLimit;
  93     bool        lowMemoryMode;
  94     double      heapTargetUtilization;
  95     size_t      heapMinFree;
  96     size_t      heapMaxFree;
  97     size_t      stackSize;
  98     size_t      mainThreadStackSize;
  99
 100     bool        verboseGc;
 101     bool        verboseJni;
 102     bool        verboseClass;
 103     bool        verboseShutdown;
 104
 105     bool        jdwpAllowed;        // debugging allowed for this process?
 106     bool        jdwpConfigured;     // has debugging info been provided?
 107     JdwpTransportType jdwpTransport;
 108     bool        jdwpServer;
 109     char*       jdwpHost;
 110     int         jdwpPort;
 111     bool        jdwpSuspend;
 112
 113     ProfilerClockSource profilerClockSource;
 114
 115     /*
 116      * Lock profiling threshold value in milliseconds.  Acquires that
 117      * exceed threshold are logged.  Acquires within the threshold are
 118      * logged with a probability of $\frac{time}{threshold}$ .  If the
 119      * threshold is unset no additional logging occurs.
 120      */
 121     u4          lockProfThreshold;
 122
 123     int         (*vfprintfHook)(FILE*, const char*, va_list);
 124     void        (*exitHook)(int);
 125     void        (*abortHook)(void);
 126     bool        (*isSensitiveThreadHook)(void);
 127
 128     char*       jniTrace;
 129     bool        reduceSignals;
 130     bool        noQuitHandler;
 131     bool        verifyDexChecksum;
 132     char*       stackTraceFile;     // for SIGQUIT-inspired output
 133
 134     bool        logStdio;
 135
 136     DexOptimizerMode    dexOptMode;
 137     DexClassVerifyMode  classVerifyMode;
 138
 139     bool        generateRegisterMaps;
 140     RegisterMapMode     registerMapMode;
 141
 142     bool        monitorVerification;
 143
 144     bool        dexOptForSmp;
 145
 146     /*
 147      * GC option flags.
 148      */
 149     bool        preciseGc;
 150     bool        preVerify;
 151     bool        postVerify;
 152     bool        concurrentMarkSweep;
 153     bool        verifyCardTable;
 154     bool        disableExplicitGc;
 155
 156     int         assertionCtrlCount;
 157     AssertionControl*   assertionCtrl;
 158
 159     ExecutionMode   executionMode;
 160
 161     bool        commonInit; /* whether common stubs are generated */
 162     bool        constInit; /* whether global constants are initialized */
 163
 164     /*
 165      * VM init management.
 166      */
 167     bool        initializing;
 168     bool        optimizing;
 169
 170     /*
 171      * java.lang.System properties set from the command line with -D.
 172      * This is effectively a set, where later entries override earlier
 173      * ones.
 174      */
 175     std::vector<std::string>* properties;
 176
 177     /*
 178      * Where the VM goes to find system classes.
 179      */
 180     ClassPathEntry* bootClassPath;
 181     /* used by the DEX optimizer to load classes from an unfinished DEX */
 182     DvmDex*     bootClassPathOptExtra;
 183     bool        optimizingBootstrapClass;
 184
 185     /*
 186      * Loaded classes, hashed by class name.  Each entry is a ClassObject*,
 187      * allocated in GC space.
 188      */
 189     HashTable*  loadedClasses;
 190
 191     /*
 192      * Value for the next class serial number to be assigned.  This is
 193      * incremented as we load classes.  Failed loads and races may result
 194      * in some numbers being skipped, and the serial number is not
 195      * guaranteed to start at 1, so the current value should not be used
 196      * as a count of loaded classes.
 197      */
 198     volatile int classSerialNumber;
 199
 200     /*
 201      * Classes with a low classSerialNumber are probably in the zygote, and
 202      * their InitiatingLoaderList is not used, to promote sharing. The list is
 203      * kept here instead.
 204      */
 205     InitiatingLoaderList* initiatingLoaderList;
 206
 207     /*
 208      * Interned strings.
 209      */
 210
 211     /* A mutex that guards access to the interned string tables. */
 212     pthread_mutex_t internLock;
 213
 214     /* Hash table of strings interned by the user. */
 215     HashTable*  internedStrings;
 216
 217     /* Hash table of strings interned by the class loader. */
 218     HashTable*  literalStrings;
 219
 220     /*
 221      * Classes constructed directly by the vm.
 222      */
 223
 224     /* the class Class */
 225     ClassObject* classJavaLangClass;
 226
 227     /* synthetic classes representing primitive types */
 228     ClassObject* typeVoid;
 229     ClassObject* typeBoolean;
 230     ClassObject* typeByte;
 231     ClassObject* typeShort;
 232     ClassObject* typeChar;
 233     ClassObject* typeInt;
 234     ClassObject* typeLong;
 235     ClassObject* typeFloat;
 236     ClassObject* typeDouble;
 237
 238     /* synthetic classes for arrays of primitives */
 239     ClassObject* classArrayBoolean;
 240     ClassObject* classArrayByte;
 241     ClassObject* classArrayShort;
 242     ClassObject* classArrayChar;
 243     ClassObject* classArrayInt;
 244     ClassObject* classArrayLong;
 245     ClassObject* classArrayFloat;
 246     ClassObject* classArrayDouble;
 247
 248     /*
 249      * Quick lookups for popular classes used internally.
 250      */
 251     ClassObject* classJavaLangClassArray;
 252     ClassObject* classJavaLangClassLoader;
 253     ClassObject* classJavaLangObject;
 254     ClassObject* classJavaLangObjectArray;
 255     ClassObject* classJavaLangString;
 256     ClassObject* classJavaLangThread;
 257     ClassObject* classJavaLangVMThread;
 258     ClassObject* classJavaLangThreadGroup;
 259     ClassObject* classJavaLangStackTraceElement;
 260     ClassObject* classJavaLangStackTraceElementArray;
 261     ClassObject* classJavaLangAnnotationAnnotationArray;
 262     ClassObject* classJavaLangAnnotationAnnotationArrayArray;
 263     ClassObject* classJavaLangReflectAccessibleObject;
 264     ClassObject* classJavaLangReflectConstructor;
 265     ClassObject* classJavaLangReflectConstructorArray;
 266     ClassObject* classJavaLangReflectField;
 267     ClassObject* classJavaLangReflectFieldArray;
 268     ClassObject* classJavaLangReflectMethod;
 269     ClassObject* classJavaLangReflectMethodArray;
 270     ClassObject* classJavaLangReflectProxy;
 271     ClassObject* classJavaLangSystem;
 272     ClassObject* classJavaNioDirectByteBuffer;
 273     ClassObject* classLibcoreReflectAnnotationFactory;
 274     ClassObject* classLibcoreReflectAnnotationMember;
 275     ClassObject* classLibcoreReflectAnnotationMemberArray;
 276     ClassObject* classOrgApacheHarmonyDalvikDdmcChunk;
 277     ClassObject* classOrgApacheHarmonyDalvikDdmcDdmServer;
 278     ClassObject* classJavaLangRefFinalizerReference;
 279
 280     /*
 281      * classes representing exception types. The names here don't include
 282      * packages, just to keep the use sites a bit less verbose. All are
 283      * in java.lang, except where noted.
 284      */
 285     ClassObject* exAbstractMethodError;
 286     ClassObject* exArithmeticException;
 287     ClassObject* exArrayIndexOutOfBoundsException;
 288     ClassObject* exArrayStoreException;
 289     ClassObject* exClassCastException;
 290     ClassObject* exClassCircularityError;
 291     ClassObject* exClassFormatError;
 292     ClassObject* exClassNotFoundException;
 293     ClassObject* exError;
 294     ClassObject* exExceptionInInitializerError;
 295     ClassObject* exFileNotFoundException; /* in java.io */
 296     ClassObject* exIOException;           /* in java.io */
 297     ClassObject* exIllegalAccessError;
 298     ClassObject* exIllegalAccessException;
 299     ClassObject* exIllegalArgumentException;
 300     ClassObject* exIllegalMonitorStateException;
 301     ClassObject* exIllegalStateException;
 302     ClassObject* exIllegalThreadStateException;
 303     ClassObject* exIncompatibleClassChangeError;
 304     ClassObject* exInstantiationError;
 305     ClassObject* exInstantiationException;
 306     ClassObject* exInternalError;
 307     ClassObject* exInterruptedException;
 308     ClassObject* exLinkageError;
 309     ClassObject* exNegativeArraySizeException;
 310     ClassObject* exNoClassDefFoundError;
 311     ClassObject* exNoSuchFieldError;
 312     ClassObject* exNoSuchFieldException;
 313     ClassObject* exNoSuchMethodError;
 314     ClassObject* exNullPointerException;
 315     ClassObject* exOutOfMemoryError;
 316     ClassObject* exRuntimeException;
 317     ClassObject* exStackOverflowError;
 318     ClassObject* exStaleDexCacheError;    /* in dalvik.system */
 319     ClassObject* exStringIndexOutOfBoundsException;
 320     ClassObject* exThrowable;
 321     ClassObject* exTypeNotPresentException;
 322     ClassObject* exUnsatisfiedLinkError;
 323     ClassObject* exUnsupportedOperationException;
 324     ClassObject* exVerifyError;
 325     ClassObject* exVirtualMachineError;
 326
 327     /* method offsets - Object */
 328     int         voffJavaLangObject_equals;
 329     int         voffJavaLangObject_hashCode;
 330     int         voffJavaLangObject_toString;
 331
 332     /* field offsets - String */
 333     int         offJavaLangString_value;
 334     int         offJavaLangString_count;
 335     int         offJavaLangString_offset;
 336     int         offJavaLangString_hashCode;
 337
 338     /* field offsets - Thread */
 339     int         offJavaLangThread_vmThread;
 340     int         offJavaLangThread_group;
 341     int         offJavaLangThread_daemon;
 342     int         offJavaLangThread_name;
 343     int         offJavaLangThread_priority;
 344     int         offJavaLangThread_uncaughtHandler;
 345     int         offJavaLangThread_contextClassLoader;
 346
 347     /* method offsets - Thread */
 348     int         voffJavaLangThread_run;
 349
 350     /* field offsets - ThreadGroup */
 351     int         offJavaLangThreadGroup_name;
 352     int         offJavaLangThreadGroup_parent;
 353
 354     /* field offsets - VMThread */
 355     int         offJavaLangVMThread_thread;
 356     int         offJavaLangVMThread_vmData;
 357
 358     /* method offsets - ThreadGroup */
 359     int         voffJavaLangThreadGroup_removeThread;
 360
 361     /* field offsets - Throwable */
 362     int         offJavaLangThrowable_stackState;
 363     int         offJavaLangThrowable_cause;
 364
 365     /* method offsets - ClassLoader */
 366     int         voffJavaLangClassLoader_loadClass;
 367
 368     /* direct method pointers - ClassLoader */
 369     Method*     methJavaLangClassLoader_getSystemClassLoader;
 370
 371     /* field offsets - java.lang.reflect.* */
 372     int         offJavaLangReflectConstructor_slot;
 373     int         offJavaLangReflectConstructor_declClass;
 374     int         offJavaLangReflectField_slot;
 375     int         offJavaLangReflectField_declClass;
 376     int         offJavaLangReflectMethod_slot;
 377     int         offJavaLangReflectMethod_declClass;
 378
 379     /* field offsets - java.lang.ref.Reference */
 380     int         offJavaLangRefReference_referent;
 381     int         offJavaLangRefReference_queue;
 382     int         offJavaLangRefReference_queueNext;
 383     int         offJavaLangRefReference_pendingNext;
 384
 385     /* field offsets - java.lang.ref.FinalizerReference */
 386     int offJavaLangRefFinalizerReference_zombie;
 387
 388     /* method pointers - java.lang.ref.ReferenceQueue */
 389     Method* methJavaLangRefReferenceQueueAdd;
 390
 391     /* method pointers - java.lang.ref.FinalizerReference */
 392     Method* methJavaLangRefFinalizerReferenceAdd;
 393
 394     /* constructor method pointers; no vtable involved, so use Method* */
 395     Method*     methJavaLangStackTraceElement_init;
 396     Method*     methJavaLangReflectConstructor_init;
 397     Method*     methJavaLangReflectField_init;
 398     Method*     methJavaLangReflectMethod_init;
 399     Method*     methOrgApacheHarmonyLangAnnotationAnnotationMember_init;
 400
 401     /* static method pointers - android.lang.annotation.* */
 402     Method*
 403         methOrgApacheHarmonyLangAnnotationAnnotationFactory_createAnnotation;
 404
 405     /* direct method pointers - java.lang.reflect.Proxy */
 406     Method*     methJavaLangReflectProxy_constructorPrototype;
 407
 408     /* field offsets - java.lang.reflect.Proxy */
 409     int         offJavaLangReflectProxy_h;
 410
 411     /* direct method pointer - java.lang.System.runFinalization */
 412     Method*     methJavaLangSystem_runFinalization;
 413
 414     /* field offsets - java.io.FileDescriptor */
 415     int         offJavaIoFileDescriptor_descriptor;
 416
 417     /* direct method pointers - dalvik.system.NativeStart */
 418     Method*     methDalvikSystemNativeStart_main;
 419     Method*     methDalvikSystemNativeStart_run;
 420
 421     /* assorted direct buffer helpers */
 422     Method*     methJavaNioDirectByteBuffer_init;
 423     int         offJavaNioBuffer_capacity;
 424     int         offJavaNioBuffer_effectiveDirectAddress;
 425
 426     /* direct method pointers - org.apache.harmony.dalvik.ddmc.DdmServer */
 427     Method*     methDalvikDdmcServer_dispatch;
 428     Method*     methDalvikDdmcServer_broadcast;
 429
 430     /* field offsets - org.apache.harmony.dalvik.ddmc.Chunk */
 431     int         offDalvikDdmcChunk_type;
 432     int         offDalvikDdmcChunk_data;
 433     int         offDalvikDdmcChunk_offset;
 434     int         offDalvikDdmcChunk_length;
 435
 436     /*
 437      * Thread list.  This always has at least one element in it (main),
 438      * and main is always the first entry.
 439      *
 440      * The threadListLock is used for several things, including the thread
 441      * start condition variable.  Generally speaking, you must hold the
 442      * threadListLock when:
 443      *  - adding/removing items from the list
 444      *  - waiting on or signaling threadStartCond
 445      *  - examining the Thread struct for another thread (this is to avoid
 446      *    one thread freeing the Thread struct while another thread is
 447      *    perusing it)
 448      */
 449     Thread*     threadList;
 450     pthread_mutex_t threadListLock;
 451
 452     pthread_cond_t threadStartCond;
 453
 454     /*
 455      * The thread code grabs this before suspending all threads.  There
 456      * are a few things that can cause a "suspend all":
 457      *  (1) the GC is starting;
 458      *  (2) the debugger has sent a "suspend all" request;
 459      *  (3) a thread has hit a breakpoint or exception that the debugger
 460      *      has marked as a "suspend all" event;
 461      *  (4) the SignalCatcher caught a signal that requires suspension.
 462      *  (5) (if implemented) the JIT needs to perform a heavyweight
 463      *      rearrangement of the translation cache or JitTable.
 464      *
 465      * Because we use "safe point" self-suspension, it is never safe to
 466      * do a blocking "lock" call on this mutex -- if it has been acquired,
 467      * somebody is probably trying to put you to sleep.  The leading '_' is
 468      * intended as a reminder that this lock is special.
 469      */
 470     pthread_mutex_t _threadSuspendLock;
 471
 472     /*
 473      * Guards Thread->suspendCount for all threads, and
 474      * provides the lock for the condition variable that all suspended threads
 475      * sleep on (threadSuspendCountCond).
 476      *
 477      * This has to be separate from threadListLock because of the way
 478      * threads put themselves to sleep.
 479      */
 480     pthread_mutex_t threadSuspendCountLock;
 481
 482     /*
 483      * Suspended threads sleep on this.  They should sleep on the condition
 484      * variable until their "suspend count" is zero.
 485      *
 486      * Paired with "threadSuspendCountLock".
 487      */
 488     pthread_cond_t  threadSuspendCountCond;
 489
 490     /*
 491      * Sum of all threads' suspendCount fields. Guarded by
 492      * threadSuspendCountLock.
 493      */
 494     int  sumThreadSuspendCount;
 495
 496     /*
 497      * MUTEX ORDERING: when locking multiple mutexes, always grab them in
 498      * this order to avoid deadlock:
 499      *
 500      *  (1) _threadSuspendLock      (use lockThreadSuspend())
 501      *  (2) threadListLock          (use dvmLockThreadList())
 502      *  (3) threadSuspendCountLock  (use lockThreadSuspendCount())
 503      */
 504
 505
 506     /*
 507      * Thread ID bitmap.  We want threads to have small integer IDs so
 508      * we can use them in "thin locks".
 509      */
 510     BitVector*  threadIdMap;
 511
 512     /*
 513      * Manage exit conditions.  The VM exits when all non-daemon threads
 514      * have exited.  If the main thread returns early, we need to sleep
 515      * on a condition variable.
 516      */
 517     int         nonDaemonThreadCount;   /* must hold threadListLock to access */
 518     pthread_cond_t  vmExitCond;
 519
 520     /*
 521      * The set of DEX files loaded by custom class loaders.
 522      */
 523     HashTable*  userDexFiles;
 524
 525     /*
 526      * JNI global reference table.
 527      */
 528     IndirectRefTable jniGlobalRefTable;
 529     IndirectRefTable jniWeakGlobalRefTable;
 530     pthread_mutex_t jniGlobalRefLock;
 531     pthread_mutex_t jniWeakGlobalRefLock;
 532
 533     /*
 534      * JNI pinned object table (used for primitive arrays).
 535      */
 536     ReferenceTable  jniPinRefTable;
 537     pthread_mutex_t jniPinRefLock;
 538
 539     /*
 540      * Native shared library table.
 541      */
 542     HashTable*  nativeLibs;
 543
 544     /*
 545      * GC heap lock.  Functions like gcMalloc() acquire this before making
 546      * any changes to the heap.  It is held throughout garbage collection.
 547      */
 548     pthread_mutex_t gcHeapLock;
 549
 550     /*
 551      * Condition variable to queue threads waiting to retry an
 552      * allocation.  Signaled after a concurrent GC is completed.
 553      */
 554     pthread_cond_t gcHeapCond;
 555
 556     /* Opaque pointer representing the heap. */
 557     GcHeap*     gcHeap;
 558
 559     /* The card table base, modified as needed for marking cards. */
 560     u1*         biasedCardTableBase;
 561
 562     /*
 563      * Pre-allocated throwables.
 564      */
 565     Object*     outOfMemoryObj;
 566     Object*     internalErrorObj;
 567     Object*     noClassDefFoundErrorObj;
 568
 569     /* Monitor list, so we can free them */
 570     /*volatile*/ Monitor* monitorList;
 571
 572     /* Monitor for Thread.sleep() implementation */
 573     Monitor*    threadSleepMon;
 574
 575     /* set when we create a second heap inside the zygote */
 576     bool        newZygoteHeapAllocated;
 577
 578     /*
 579      * TLS keys.
 580      */
 581     pthread_key_t pthreadKeySelf;       /* Thread*, for dvmThreadSelf */
 582
 583     /*
 584      * Cache results of "A instanceof B".
 585      */
 586     AtomicCache* instanceofCache;
 587
 588     /* inline substitution table, used during optimization */
 589     InlineSub*          inlineSubs;
 590
 591     /*
 592      * Bootstrap class loader linear allocator.
 593      */
 594     LinearAllocHdr* pBootLoaderAlloc;
 595
 596     /*
 597      * Compute some stats on loaded classes.
 598      */
 599     int         numLoadedClasses;
 600     int         numDeclaredMethods;
 601     int         numDeclaredInstFields;
 602     int         numDeclaredStaticFields;
 603
 604     /* when using a native debugger, set this to suppress watchdog timers */
 605     bool        nativeDebuggerActive;
 606
 607     /*
 608      * JDWP debugger support.
 609      *
 610      * Note: Each thread will normally determine whether the debugger is active
 611      * for it by referring to its subMode flags.  "debuggerActive" here should be
 612      * seen as "debugger is making requests of 1 or more threads".
 613      */
 614     bool        debuggerConnected;      /* debugger or DDMS is connected */
 615     bool        debuggerActive;         /* debugger is making requests */
 616     JdwpState*  jdwpState;
 617
 618     /*
 619      * Registry of objects known to the debugger.
 620      */
 621     HashTable*  dbgRegistry;
 622
 623     /*
 624      * Debugger breakpoint table.
 625      */
 626     BreakpointSet*  breakpointSet;
 627
 628     /*
 629      * Single-step control struct.  We currently only allow one thread to
 630      * be single-stepping at a time, which is all that really makes sense,
 631      * but it's possible we may need to expand this to be per-thread.
 632      */
 633     StepControl stepControl;
 634
 635     /*
 636      * DDM features embedded in the VM.
 637      */
 638     bool        ddmThreadNotification;
 639
 640     /*
 641      * Zygote (partially-started process) support
 642      */
 643     bool        zygote;
 644
 645     /*
 646      * Used for tracking allocations that we report to DDMS.  When the feature
 647      * is enabled (through a DDMS request) the "allocRecords" pointer becomes
 648      * non-NULL.
 649      */
 650     pthread_mutex_t allocTrackerLock;
 651     AllocRecord*    allocRecords;
 652     int             allocRecordHead;        /* most-recently-added entry */
 653     int             allocRecordCount;       /* #of valid entries */
 654     int             allocRecordMax;         /* Number of allocated entries. */
 655
 656     /*
 657      * When a profiler is enabled, this is incremented.  Distinct profilers
 658      * include "dmtrace" method tracing, emulator method tracing, and
 659      * possibly instruction counting.
 660      *
 661      * The purpose of this is to have a single value that shows whether any
 662      * profiling is going on.  Individual thread will normally check their
 663      * thread-private subMode flags to take any profiling action.
 664      */
 665     volatile int activeProfilers;
 666
 667     /*
 668      * State for method-trace profiling.
 669      */
 670     MethodTraceState methodTrace;
 671     Method*     methodTraceGcMethod;
 672     Method*     methodTraceClassPrepMethod;
 673
 674     /*
 675      * State for emulator tracing.
 676      */
 677     void*       emulatorTracePage;
 678     int         emulatorTraceEnableCount;
 679
 680     /*
 681      * Global state for memory allocation profiling.
 682      */
 683     AllocProfState allocProf;
 684
 685     /*
 686      * Pointers to the original methods for things that have been inlined.
 687      * This makes it easy for us to output method entry/exit records for
 688      * the method calls we're not actually making.  (Used by method
 689      * profiling.)
 690      */
 691     Method**    inlinedMethods;
 692
 693     /*
 694      * Dalvik instruction counts (kNumPackedOpcodes entries).
 695      */
 696     int*        executedInstrCounts;
 697     int         instructionCountEnableCount;
 698
 699     /*
 700      * Signal catcher thread (for SIGQUIT).
 701      */
 702     pthread_t   signalCatcherHandle;
 703     bool        haltSignalCatcher;
 704
 705     /*
 706      * Stdout/stderr conversion thread.
 707      */
 708     bool            haltStdioConverter;
 709     bool            stdioConverterReady;
 710     pthread_t       stdioConverterHandle;
 711     pthread_mutex_t stdioConverterLock;
 712     pthread_cond_t  stdioConverterCond;
 713     int             stdoutPipe[2];
 714     int             stderrPipe[2];
 715
 716     /*
 717      * pid of the system_server process. We track it so that when system server
 718      * crashes the Zygote process will be killed and restarted.
 719      */
 720     pid_t systemServerPid;
 721
 722     int kernelGroupScheduling;
 723
 724 //#define COUNT_PRECISE_METHODS
 725 #ifdef COUNT_PRECISE_METHODS
 726     PointerSet* preciseMethods;
 727 #endif
 728
 729     /* some RegisterMap statistics, useful during development */
 730     void*       registerMapStats;
 731
 732 #ifdef VERIFIER_STATS
 733     VerifierStats verifierStats;
 734 #endif
 735
 736     /* String pointed here will be deposited on the stack frame of dvmAbort */
 737     const char *lastMessage;
 738 };
 739
 740 extern struct DvmGlobals gDvm;
 741
 742 #if defined(WITH_JIT)
 743
 744 #define DEFAULT_CODE_CACHE_SIZE 0xffffffff
 745
 746 /* Trace profiling modes.  Ordering matters - off states before on states */
 747 enum TraceProfilingModes {
 748     kTraceProfilingDisabled = 0,      // Not profiling
 749     kTraceProfilingPeriodicOff = 1,   // Periodic profiling, off phase
 750     kTraceProfilingContinuous = 2,    // Always profiling
 751     kTraceProfilingPeriodicOn = 3     // Periodic profiling, on phase
 752 };
 753
 754 /*
 755  * Exiting the compiled code w/o chaining will incur overhead to look up the
 756  * target in the code cache which is extra work only when JIT is enabled. So
 757  * we want to monitor it closely to make sure we don't have performance bugs.
 758  */
 759 enum NoChainExits {
 760     kInlineCacheMiss = 0,
 761     kCallsiteInterpreted,
 762     kSwitchOverflow,
 763     kHeavyweightMonitor,
 764     kNoChainExitLast,
 765 };
 766
 767 /*
 768  * JIT-specific global state
 769  */
 770 struct DvmJitGlobals {
 771     /*
 772      * Guards writes to Dalvik PC (dPC), translated code address (codeAddr) and
 773      * chain fields within the JIT hash table.  Note carefully the access
 774      * mechanism.
 775      * Only writes are guarded, and the guarded fields must be updated in a
 776      * specific order using atomic operations.  Further, once a field is
 777      * written it cannot be changed without halting all threads.
 778      *
 779      * The write order is:
 780      *    1) codeAddr
 781      *    2) dPC
 782      *    3) chain [if necessary]
 783      *
 784      * This mutex also guards both read and write of curJitTableEntries.
 785      */
 786     pthread_mutex_t tableLock;
 787
 788     /* The JIT hash table.  Note that for access speed, copies of this pointer
 789      * are stored in each thread. */
 790     struct JitEntry *pJitEntryTable;
 791
 792     /* Array of compilation trigger threshold counters */
 793     unsigned char *pProfTable;
 794
 795     /* Trace profiling counters */
 796     struct JitTraceProfCounters *pJitTraceProfCounters;
 797
 798     /* Copy of pProfTable used for temporarily disabling the Jit */
 799     unsigned char *pProfTableCopy;
 800
 801     /* Size of JIT hash table in entries.  Must be a power of 2 */
 802     unsigned int jitTableSize;
 803
 804     /* Mask used in hash function for JitTable.  Should be jitTableSize-1 */
 805     unsigned int jitTableMask;
 806
 807     /* How many entries in the JitEntryTable are in use */
 808     unsigned int jitTableEntriesUsed;
 809
 810     /* Max bytes allocated for the code cache.  Rough rule of thumb: 1K per 1M of system RAM */
 811     unsigned int codeCacheSize;
 812
 813     /* Trigger for trace selection */
 814     unsigned short threshold;
 815
 816     /* JIT Compiler Control */
 817     bool               haltCompilerThread;
 818     bool               blockingMode;
 819     bool               methodTraceSupport;
 820     bool               genSuspendPoll;
 821     Thread*            compilerThread;
 822     pthread_t          compilerHandle;
 823     pthread_mutex_t    compilerLock;
 824     pthread_mutex_t    compilerICPatchLock;
 825     pthread_cond_t     compilerQueueActivity;
 826     pthread_cond_t     compilerQueueEmpty;
 827     volatile int       compilerQueueLength;
 828     int                compilerHighWater;
 829     int                compilerWorkEnqueueIndex;
 830     int                compilerWorkDequeueIndex;
 831     int                compilerICPatchIndex;
 832
 833     /* JIT internal stats */
 834     int                compilerMaxQueued;
 835     int                translationChains;
 836
 837     /* Compiled code cache */
 838     void* codeCache;
 839
 840     /*
 841      * This is used to store the base address of an in-flight compilation whose
 842      * class object pointers have been calculated to populate literal pool.
 843      * Once the compiler thread has changed its status to VM_WAIT, we cannot
 844      * guarantee whether GC has happened before the code address has been
 845      * installed to the JIT table. Because of that, this field can only
 846      * been cleared/overwritten by the compiler thread if it is in the
 847      * THREAD_RUNNING state or in a safe point.
 848      */
 849     void *inflightBaseAddr;
 850
 851     /* Translation cache version (protected by compilerLock */
 852     int cacheVersion;
 853
 854     /* Bytes used by the code templates */
 855     unsigned int templateSize;
 856
 857     /* Bytes already used in the code cache */
 858     unsigned int codeCacheByteUsed;
 859
 860     /* Number of installed compilations in the cache */
 861     unsigned int numCompilations;
 862
 863     /* Flag to indicate that the code cache is full */
 864     bool codeCacheFull;
 865
 866     /* Page size  - 1 */
 867     unsigned int pageSizeMask;
 868
 869     /* Lock to change the protection type of the code cache */
 870     pthread_mutex_t    codeCacheProtectionLock;
 871
 872     /* Number of times that the code cache has been reset */
 873     int numCodeCacheReset;
 874
 875     /* Number of times that the code cache reset request has been delayed */
 876     int numCodeCacheResetDelayed;
 877
 878     /* true/false: compile/reject opcodes specified in the -Xjitop list */
 879     bool includeSelectedOp;
 880
 881     /* true/false: compile/reject methods specified in the -Xjitmethod list */
 882     bool includeSelectedMethod;
 883
 884     /* true/false: compile/reject traces with offset specified in the -Xjitoffset list */
 885     bool includeSelectedOffset;
 886
 887     /* Disable JIT for selected opcodes - one bit for each opcode */
 888     char opList[(kNumPackedOpcodes+7)/8];
 889
 890     /* Disable JIT for selected methods */
 891     HashTable *methodTable;
 892
 893     /* Disable JIT for selected classes */
 894     HashTable *classTable;
 895
 896     /* Disable JIT for selected offsets */
 897     unsigned int pcTable[COMPILER_PC_OFFSET_SIZE];
 898     int num_entries_pcTable;
 899
 900     /* Flag to dump all compiled code */
 901     bool printMe;
 902
 903     /* Flag to dump compiled binary code in bytes */
 904     bool printBinary;
 905
 906     /* Per-process debug flag toggled when receiving a SIGUSR2 */
 907     bool receivedSIGUSR2;
 908
 909     /* Trace profiling mode */
 910     TraceProfilingModes profileMode;
 911
 912     /* Periodic trace profiling countdown timer */
 913     int profileCountdown;
 914
 915     /* Vector to disable selected optimizations */
 916     int disableOpt;
 917
 918     /* Table to track the overall and trace statistics of hot methods */
 919     HashTable*  methodStatsTable;
 920
 921     /* Filter method compilation blacklist with call-graph information */
 922     bool checkCallGraph;
 923
 924     /* New translation chain has been set up */
 925     volatile bool hasNewChain;
 926
 927 #if defined(WITH_SELF_VERIFICATION)
 928     /* Spin when error is detected, volatile so GDB can reset it */
 929     volatile bool selfVerificationSpin;
 930 #endif
 931
 932     /* Framework or stand-alone? */
 933     bool runningInAndroidFramework;
 934
 935     /* Framework callback happened? */
 936     bool alreadyEnabledViaFramework;
 937
 938     /* Framework requests to disable the JIT for good */
 939     bool disableJit;
 940
 941 #if defined(SIGNATURE_BREAKPOINT)
 942     /* Signature breakpoint */
 943     u4 signatureBreakpointSize;         // # of words
 944     u4 *signatureBreakpoint;            // Signature content
 945 #endif
 946
 947 #if defined(WITH_JIT_TUNING)
 948     /* Performance tuning counters */
 949     int                addrLookupsFound;
 950     int                addrLookupsNotFound;
 951     int                noChainExit[kNoChainExitLast];
 952     int                normalExit;
 953     int                puntExit;
 954     int                invokeMonomorphic;
 955     int                invokePolymorphic;
 956     int                invokeNative;
 957     int                invokeMonoGetterInlined;
 958     int                invokeMonoSetterInlined;
 959     int                invokePolyGetterInlined;
 960     int                invokePolySetterInlined;
 961     int                returnOp;
 962     int                icPatchInit;
 963     int                icPatchLockFree;
 964     int                icPatchQueued;
 965     int                icPatchRejected;
 966     int                icPatchDropped;
 967     int                codeCachePatches;
 968     int                numCompilerThreadBlockGC;
 969     u8                 jitTime;
 970     u8                 compilerThreadBlockGCStart;
 971     u8                 compilerThreadBlockGCTime;
 972     u8                 maxCompilerThreadBlockGCTime;
 973 #endif
 974
 975 #if defined(ARCH_IA32)
 976     JitOptLevel        optLevel;
 977 #endif
 978
 979     /* Place arrays at the end to ease the display in gdb sessions */
 980
 981     /* Work order queue for compilations */
 982     CompilerWorkOrder compilerWorkQueue[COMPILER_WORK_QUEUE_SIZE];
 983
 984     /* Work order queue for predicted chain patching */
 985     ICPatchWorkOrder compilerICPatchQueue[COMPILER_IC_PATCH_QUEUE_SIZE];
 986 };
 987
 988 extern struct DvmJitGlobals gDvmJit;
 989
 990 #if defined(WITH_JIT_TUNING)
 991 extern int gDvmICHitCount;
 992 #endif
 993
 994 #endif
 995
 996 struct DvmJniGlobals {
 997     bool useCheckJni;
 998     bool warnOnly;
 999     bool forceCopy;
1000
1001     // Provide backwards compatibility for pre-ICS apps on ICS.
1002     bool workAroundAppJniBugs;
1003
1004     // Debugging help for third-party developers. Similar to -Xjnitrace.
1005     bool logThirdPartyJni;
1006
1007     // We only support a single JavaVM per process.
1008     JavaVM*     jniVm;
1009 };
1010
1011 extern struct DvmJniGlobals gDvmJni;
1012
1013 #endif  // DALVIK_GLOBALS_H_