hotspot/src/share/vm/runtime/thread.hpp
author kvn
Wed, 19 Feb 2014 12:08:49 -0800
changeset 22876 57aa8995d43b
parent 22556 a17351e8c2c2
parent 22870 f939d9a0440d
child 22905 4b1549d69106
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
22539
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 20707
diff changeset
     2
 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5252
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5252
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5252
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    25
#ifndef SHARE_VM_RUNTIME_THREAD_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    26
#define SHARE_VM_RUNTIME_THREAD_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    28
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    29
#include "memory/threadLocalAllocBuffer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    30
#include "oops/oop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    31
#include "prims/jni.h"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    32
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    33
#include "runtime/frame.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    34
#include "runtime/javaFrameAnchor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    35
#include "runtime/jniHandles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    36
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    37
#include "runtime/os.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    38
#include "runtime/osThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    39
#include "runtime/park.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    40
#include "runtime/safepoint.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    41
#include "runtime/stubRoutines.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    42
#include "runtime/threadLocalStorage.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    43
#include "runtime/unhandledOops.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
    44
#include "utilities/macros.hpp"
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
    45
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
    46
#if INCLUDE_NMT
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
    47
#include "services/memRecorder.hpp"
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
    48
#endif // INCLUDE_NMT
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
    49
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17867
diff changeset
    50
#include "trace/traceBackend.hpp"
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17867
diff changeset
    51
#include "trace/traceMacros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    52
#include "utilities/exceptions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    53
#include "utilities/top.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
    54
#if INCLUDE_ALL_GCS
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    55
#include "gc_implementation/g1/dirtyCardQueue.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    56
#include "gc_implementation/g1/satbQueue.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
    57
#endif // INCLUDE_ALL_GCS
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    58
#ifdef ZERO
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    59
#ifdef TARGET_ARCH_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    60
# include "stack_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    61
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    62
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    63
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
class ThreadSafepointState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
class ThreadProfiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
class JvmtiThreadState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
class JvmtiGetLoadedClassesClosure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
class ThreadStatistics;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
class ConcurrentLocksDump;
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
    71
class ParkEvent;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 6769
diff changeset
    72
class Parker;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
class ciEnv;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
class CompileThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
class CompileLog;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
class CompileTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
class CompileQueue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
class CompilerCounters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
class vframeArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
class DeoptResourceMark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
class jvmtiDeferredLocalVariableSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
class GCTaskQueue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
class ThreadClosure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
class IdealGraphPrinter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
18928
ac0163dd0a50 7143807: ResourceMark nesting problem in stringStream
fparain
parents: 18025
diff changeset
    89
DEBUG_ONLY(class ResourceMark;)
ac0163dd0a50 7143807: ResourceMark nesting problem in stringStream
fparain
parents: 18025
diff changeset
    90
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
    91
class WorkerThread;
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
    92
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
// Class hierarchy
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
// - Thread
4489
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
    95
//   - NamedThread
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
    96
//     - VMThread
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
    97
//     - ConcurrentGCThread
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
    98
//     - WorkerThread
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
    99
//       - GangWorker
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   100
//       - GCTaskThread
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
//   - JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
//   - WatcherThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
class Thread: public ThreadShadow {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // Exception handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // (Note: _pending_exception and friends are in ThreadShadow)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  //oop       _pending_exception;                // pending exception for current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // const char* _exception_file;                   // file information for exception (debugging only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  // int         _exception_line;                   // line information for exception (debugging only)
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
   112
 protected:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  // Support for forcing alignment of thread objects for biased locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  void*       _real_malloc_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
 public:
19696
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 18943
diff changeset
   116
  void* operator new(size_t size) throw() { return allocate(size, true); }
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 18943
diff changeset
   117
  void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 18943
diff changeset
   118
    return allocate(size, false); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  void  operator delete(void* p);
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
   120
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
   121
 protected:
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
   122
   static void* allocate(size_t size, bool throw_excpt, MEMFLAGS flags = mtThread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // ***************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // Suspend and resume support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // ***************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // VM suspend/resume no longer exists - it was once used for various
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // things including safepoints but was deprecated and finally removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  // in Java 7. Because VM suspension was considered "internal" Java-level
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // suspension was considered "external", and this legacy naming scheme
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // remains.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  // External suspend/resume requests come from JVM_SuspendThread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // JVM_ResumeThread, JVMTI SuspendThread, and finally JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // ResumeThread. External
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // suspend requests cause _external_suspend to be set and external
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  // resume requests cause _external_suspend to be cleared.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  // External suspend requests do not nest on top of other external
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // suspend requests. The higher level APIs reject suspend requests
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // for already suspended threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // The external_suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // flag is checked by has_special_runtime_exit_condition() and java thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  // will self-suspend when handle_special_runtime_exit_condition() is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // called. Most uses of the _thread_blocked state in JavaThreads are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // considered the same as being externally suspended; if the blocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // condition lifts, the JavaThread will self-suspend. Other places
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // where VM checks for external_suspend include:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  //   + mutex granting (do not enter monitors when thread is suspended)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  //   + state transitions from _thread_in_native
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // In general, java_suspend() does not wait for an external suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // request to complete. When it returns, the only guarantee is that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // the _external_suspend field is true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // wait_for_ext_suspend_completion() is used to wait for an external
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  // suspend request to complete. External suspend requests are usually
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // followed by some other interface call that requires the thread to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // be quiescent, e.g., GetCallTrace(). By moving the "wait time" into
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // the interface that requires quiescence, we give the JavaThread a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // chance to self-suspend before we need it to be quiescent. This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // improves overall suspend/query performance.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  // _suspend_flags controls the behavior of java_ suspend/resume.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // It must be set under the protection of SR_lock. Read from the flag is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // OK without SR_lock as long as the value is only used as a hint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // (e.g., check _external_suspend first without lock and then recheck
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // inside SR_lock and finish the suspension)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // _suspend_flags is also overloaded for other "special conditions" so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // that a single check indicates whether any special action is needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // eg. for async exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // -------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // Notes:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // 1. The suspend/resume logic no longer uses ThreadState in OSThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // but we still update its value to keep other part of the system (mainly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  // JVMTI) happy. ThreadState is legacy code (see notes in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // osThread.hpp).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  // 2. It would be more natural if set_external_suspend() is private and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // part of java_suspend(), but that probably would affect the suspend/query
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // performance. Need more investigation on this.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // suspend/resume lock: used for self-suspend
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   188
  Monitor* _SR_lock;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  enum SuspendFlags {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    // NOTE: avoid using the sign-bit as cc generates different test code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    //       when the sign-bit is used, and sometimes incorrectly - see CR 6398077
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    _external_suspend       = 0x20000000U, // thread is asked to self suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    _ext_suspended          = 0x40000000U, // thread has self-suspended
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   199
    _has_async_exception    = 0x00000001U, // there is a pending async exception
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   200
    _critical_native_unlock = 0x00000002U  // Must call back to unlock JNI critical lock
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  // various suspension related flags - atomically updated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  // overloaded for async exception checking in check_special_condition_for_native_trans.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  volatile uint32_t _suspend_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  int _num_nested_signal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  void enter_signal_handler() { _num_nested_signal++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  void leave_signal_handler() { _num_nested_signal--; }
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   213
  bool is_inside_signal_handler() const { return _num_nested_signal > 0; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  // Debug tracing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  static void trace(const char* msg, const Thread* const thread) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  // Active_handles points to a block of handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  JNIHandleBlock* _active_handles;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // One-element thread local free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  JNIHandleBlock* _free_handle_block;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  // Point to the last handle mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  HandleMark* _last_handle_mark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  // The parity of the last strong_roots iteration in which this thread was
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // claimed as a task.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  jint _oops_do_parity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
   void set_last_handle_mark(HandleMark* mark)   { _last_handle_mark = mark; }
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   234
   HandleMark* last_handle_mark() const          { return _last_handle_mark; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // debug support for checking if code does allow safepoints or not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // GC points in the VM can happen because of allocation, invoking a VM operation, or blocking on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // mutex, or blocking on an object synchronizer (Java locking).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  // If !allow_safepoint(), then an assertion failure will happen in any of the above cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  // If !allow_allocation(), then an assertion failure will happen during allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  // (Hence, !allow_safepoint() => !allow_allocation()).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  // The two classes No_Safepoint_Verifier and No_Allocation_Verifier are used to set these counters.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  //
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   246
  NOT_PRODUCT(int _allow_safepoint_count;)      // If 0, thread allow a safepoint to happen
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   247
  debug_only (int _allow_allocation_count;)     // If 0, the thread is allowed to allocate oops.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
2995
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   249
  // Used by SkipGCALot class.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   250
  NOT_PRODUCT(bool _skip_gcalot;)               // Should we elide gc-a-lot?
2995
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   251
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  // Record when GC is locked out via the GC_locker mechanism
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  CHECK_UNHANDLED_OOPS_ONLY(int _gc_locked_out_count;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  friend class No_Alloc_Verifier;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  friend class No_Safepoint_Verifier;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  friend class Pause_No_Safepoint_Verifier;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  friend class ThreadLocalStorage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  friend class GC_locker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   261
  ThreadLocalAllocBuffer _tlab;                 // Thread-local eden
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   262
  jlong _allocated_bytes;                       // Cumulative number of bytes allocated on
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   263
                                                // the Java heap
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17867
diff changeset
   265
  TRACE_DATA _trace_data;                       // Thread-local data for tracing
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10739
diff changeset
   266
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   267
  int   _vm_operation_started_count;            // VM_Operation support
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   268
  int   _vm_operation_completed_count;          // VM_Operation support
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   270
  ObjectMonitor* _current_pending_monitor;      // ObjectMonitor this thread
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   271
                                                // is waiting to lock
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   272
  bool _current_pending_monitor_is_from_java;   // locking is from Java code
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  // ObjectMonitor on which this thread called Object.wait()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  ObjectMonitor* _current_waiting_monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  // Private thread-local objectmonitor list - a simple cache organized as a SLL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
 public:
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   279
  ObjectMonitor* omFreeList;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   280
  int omFreeCount;                              // length of omFreeList
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   281
  int omFreeProvision;                          // reload chunk size
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   282
  ObjectMonitor* omInUseList;                   // SLL to track monitors in circulation
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 5252
diff changeset
   283
  int omInUseCount;                             // length of omInUseList
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
12108
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   285
#ifdef ASSERT
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   286
 private:
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   287
  bool _visited_for_critical_count;
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   288
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   289
 public:
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   290
  void set_visited_for_critical_count(bool z) { _visited_for_critical_count = z; }
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   291
  bool was_visited_for_critical_count() const   { return _visited_for_critical_count; }
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   292
#endif
b2ee55606008 7150390: JFR test crashed on assert(_jni_lock_count == count) failed: must be equal
never
parents: 11637
diff changeset
   293
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    is_definitely_current_thread = true
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  Thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  virtual ~Thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // initializtion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  void initialize_thread_local_storage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // thread entry point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  // Testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  virtual bool is_VM_thread()       const            { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  virtual bool is_Java_thread()     const            { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  virtual bool is_Compiler_thread() const            { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  virtual bool is_hidden_from_external_view() const  { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  virtual bool is_jvmti_agent_thread() const         { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // True iff the thread can perform GC operations at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // Generally will be true only of VM thread and parallel GC WorkGang
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  // threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  virtual bool is_GC_task_thread() const             { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  virtual bool is_Watcher_thread() const             { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  virtual bool is_ConcurrentGC_thread() const        { return false; }
4489
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   321
  virtual bool is_Named_thread() const               { return false; }
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   322
  virtual bool is_Worker_thread() const              { return false; }
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   323
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   324
  // Casts
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   325
  virtual WorkerThread* as_Worker_thread() const     { return NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  virtual char* name() const { return (char*)"Unknown thread"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // Returns the current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  static inline Thread* current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // Common thread operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  static void set_priority(Thread* thread, ThreadPriority priority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  static ThreadPriority get_priority(const Thread* const thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  static void start(Thread* thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  static void interrupt(Thread* thr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  static bool is_interrupted(Thread* thr, bool clear_interrupted);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   339
  void set_native_thread_name(const char *name) {
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   340
    assert(Thread::current() == this, "set_native_thread_name can only be called on the current thread");
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   341
    os::set_native_thread_name(name);
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   342
  }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   343
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5713
diff changeset
   344
  ObjectMonitor** omInUseList_addr()             { return (ObjectMonitor **)&omInUseList; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  Monitor* SR_lock() const                       { return _SR_lock; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  bool has_async_exception() const { return (_suspend_flags & _has_async_exception) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  void set_suspend_flag(SuspendFlags f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    uint32_t flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
      flags = _suspend_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    while (Atomic::cmpxchg((jint)(flags | f),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
                           (volatile jint*)&_suspend_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
                           (jint)flags) != (jint)flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  void clear_suspend_flag(SuspendFlags f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    uint32_t flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
      flags = _suspend_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    while (Atomic::cmpxchg((jint)(flags & ~f),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
                           (volatile jint*)&_suspend_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
                           (jint)flags) != (jint)flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  void set_has_async_exception() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    set_suspend_flag(_has_async_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  void clear_has_async_exception() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    clear_suspend_flag(_has_async_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   377
  bool do_critical_native_unlock() const { return (_suspend_flags & _critical_native_unlock) != 0; }
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   378
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   379
  void set_critical_native_unlock() {
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   380
    set_suspend_flag(_critical_native_unlock);
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   381
  }
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   382
  void clear_critical_native_unlock() {
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   383
    clear_suspend_flag(_critical_native_unlock);
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   384
  }
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
   385
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // Support for Unhandled Oop detection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
#ifdef CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
 private:
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   389
  UnhandledOops* _unhandled_oops;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
 public:
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   391
  UnhandledOops* unhandled_oops() { return _unhandled_oops; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  // Mark oop safe for gc.  It may be stack allocated but won't move.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   393
  void allow_unhandled_oop(oop *op) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    if (CheckUnhandledOops) unhandled_oops()->allow_unhandled_oop(op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  // Clear oops at safepoint so crashes point to unhandled oop violator
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   397
  void clear_unhandled_oops() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
    if (CheckUnhandledOops) unhandled_oops()->clear_unhandled_oops();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  bool is_gc_locked_out() { return _gc_locked_out_count > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
#endif // CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
2995
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   403
#ifndef PRODUCT
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   404
  bool skip_gcalot()           { return _skip_gcalot; }
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   405
  void set_skip_gcalot(bool v) { _skip_gcalot = v;    }
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   406
#endif
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   407
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  // Installs a pending exception to be inserted later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  static void send_async_exception(oop thread_oop, oop java_throwable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  // Resource area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  ResourceArea* resource_area() const            { return _resource_area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  void set_resource_area(ResourceArea* area)     { _resource_area = area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  OSThread* osthread() const                     { return _osthread;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  void set_osthread(OSThread* thread)            { _osthread = thread; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  // JNI handle support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  JNIHandleBlock* active_handles() const         { return _active_handles; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  void set_active_handles(JNIHandleBlock* block) { _active_handles = block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  JNIHandleBlock* free_handle_block() const      { return _free_handle_block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  void set_free_handle_block(JNIHandleBlock* block) { _free_handle_block = block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  // Internal handle support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  HandleArea* handle_area() const                { return _handle_area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  void set_handle_area(HandleArea* area)         { _handle_area = area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   429
  GrowableArray<Metadata*>* metadata_handles() const          { return _metadata_handles; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   430
  void set_metadata_handles(GrowableArray<Metadata*>* handles){ _metadata_handles = handles; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   431
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  // Thread-Local Allocation Buffer (TLAB) support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  ThreadLocalAllocBuffer& tlab()                 { return _tlab; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  void initialize_tlab() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
      tlab().initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   440
  jlong allocated_bytes()               { return _allocated_bytes; }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   441
  void set_allocated_bytes(jlong value) { _allocated_bytes = value; }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   442
  void incr_allocated_bytes(jlong size) { _allocated_bytes += size; }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   443
  jlong cooked_allocated_bytes() {
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   444
    jlong allocated_bytes = OrderAccess::load_acquire(&_allocated_bytes);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   445
    if (UseTLAB) {
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   446
      size_t used_bytes = tlab().used_bytes();
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   447
      if ((ssize_t)used_bytes > 0) {
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   448
        // More-or-less valid tlab.  The load_acquire above should ensure
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   449
        // that the result of the add is <= the instantaneous value
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   450
        return allocated_bytes + used_bytes;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   451
      }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   452
    }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   453
    return allocated_bytes;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   454
  }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   455
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17867
diff changeset
   456
  TRACE_DATA* trace_data()              { return &_trace_data; }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 10739
diff changeset
   457
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  // VM operation support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  int vm_operation_ticket()                      { return ++_vm_operation_started_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  int vm_operation_completed_count()             { return _vm_operation_completed_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  void increment_vm_operation_completed_count()  { _vm_operation_completed_count++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  // For tracking the heavyweight monitor the thread is pending on.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  ObjectMonitor* current_pending_monitor() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
    return _current_pending_monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  void set_current_pending_monitor(ObjectMonitor* monitor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
    _current_pending_monitor = monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  void set_current_pending_monitor_is_from_java(bool from_java) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    _current_pending_monitor_is_from_java = from_java;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  bool current_pending_monitor_is_from_java() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
    return _current_pending_monitor_is_from_java;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  // For tracking the ObjectMonitor on which this thread called Object.wait()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  ObjectMonitor* current_waiting_monitor() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    return _current_waiting_monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  void set_current_waiting_monitor(ObjectMonitor* monitor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    _current_waiting_monitor = monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  // GC support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  // Apply "f->do_oop" to all root oops in "this".
14582
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
   487
  // Apply "cld_f->do_cld" to CLDs that are otherwise not kept alive.
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
   488
  //   Used by JavaThread::oops_do.
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
   489
  // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames
14582
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
   490
  virtual void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // Handles the parallel case for the method below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  bool claim_oops_do_par_case(int collection_parity);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  // Requires that "collection_parity" is that of the current strong roots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // iteration.  If "is_par" is false, sets the parity of "this" to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  // "collection_parity", and returns "true".  If "is_par" is true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  // uses an atomic instruction to set the current threads parity to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // "collection_parity", if it is not already.  Returns "true" iff the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // calling thread does the update, this indicates that the calling thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  // has claimed the thread's stack as a root groop in the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  // collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  bool claim_oops_do(bool is_par, int collection_parity) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
    if (!is_par) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
      _oops_do_parity = collection_parity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
      return claim_oops_do_par_case(collection_parity);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  // Sweeper support
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
   514
  void nmethods_do(CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   516
  // jvmtiRedefineClasses support
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   517
  void metadata_do(void f(Metadata*));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   518
2526
39a58a50be35 6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents: 2135
diff changeset
   519
  // Used by fast lock support
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  virtual bool is_lock_owned(address adr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  // Check if address is in the stack of the thread (not just for locks).
2526
39a58a50be35 6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents: 2135
diff changeset
   523
  // Warning: the method can only be used on the running thread
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  bool is_in_stack(address adr) const;
18938
ff8f8cec9434 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()'
rbackman
parents: 18928
diff changeset
   525
  // Check if address is in the usable part of the stack (excludes protected
ff8f8cec9434 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()'
rbackman
parents: 18928
diff changeset
   526
  // guard pages)
ff8f8cec9434 8016131: nsk/sysdict/vm/stress/chain tests crash the VM in 'entry_frame_is_first()'
rbackman
parents: 18928
diff changeset
   527
  bool is_in_usable_stack(address adr) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // Sets this thread as starting thread. Returns failure if thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // creation fails due to lack of memory, too many threads etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  bool set_as_starting_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  // OS data associated with the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  OSThread* _osthread;  // Platform-specific thread information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  // Thread local resource area for temporary allocation within the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  ResourceArea* _resource_area;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
18928
ac0163dd0a50 7143807: ResourceMark nesting problem in stringStream
fparain
parents: 18025
diff changeset
   540
  DEBUG_ONLY(ResourceMark* _current_resource_mark;)
ac0163dd0a50 7143807: ResourceMark nesting problem in stringStream
fparain
parents: 18025
diff changeset
   541
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  // Thread local handle area for allocation of handles within the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  HandleArea* _handle_area;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   544
  GrowableArray<Metadata*>* _metadata_handles;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  // Support for stack overflow handling, get_thread, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  address          _stack_base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  size_t           _stack_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  uintptr_t        _self_raw_id;      // used by get_thread (mutable)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  int              _lgrp_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // Stack overflow support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  address stack_base() const           { assert(_stack_base != NULL,"Sanity check"); return _stack_base; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  void    set_stack_base(address base) { _stack_base = base; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  size_t  stack_size() const           { return _stack_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  void    set_stack_size(size_t size)  { _stack_size = size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  void    record_stack_base_and_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
6183
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5920
diff changeset
   561
  bool    on_local_stack(address adr) const {
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5920
diff changeset
   562
    /* QQQ this has knowledge of direction, ought to be a stack method */
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5920
diff changeset
   563
    return (_stack_base >= adr && adr >= (_stack_base - _stack_size));
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5920
diff changeset
   564
  }
4c74cfe14f20 6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents: 5920
diff changeset
   565
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   566
  uintptr_t self_raw_id()                    { return _self_raw_id; }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   567
  void      set_self_raw_id(uintptr_t value) { _self_raw_id = value; }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   568
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   569
  int     lgrp_id() const        { return _lgrp_id; }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   570
  void    set_lgrp_id(int value) { _lgrp_id = value; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  void print() const { print_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  virtual void print_on_error(outputStream* st, char* buf, int buflen) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  // Debug-only code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  // Deadlock detection support for Mutex locks. List of locks own by thread.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   581
  Monitor* _owned_locks;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // Mutex::set_owner_implementation is the only place where _owned_locks is modified,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // thus the friendship
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  friend class Mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  friend class Monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  void print_owned_locks_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  void print_owned_locks() const                 { print_owned_locks_on(tty);    }
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   590
  Monitor* owned_locks() const                   { return _owned_locks;          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  bool owns_locks() const                        { return owned_locks() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  bool owns_locks_but_compiled_lock() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  // Deadlock detection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  bool allow_allocation()                        { return _allow_allocation_count == 0; }
18928
ac0163dd0a50 7143807: ResourceMark nesting problem in stringStream
fparain
parents: 18025
diff changeset
   596
  ResourceMark* current_resource_mark()          { return _current_resource_mark; }
ac0163dd0a50 7143807: ResourceMark nesting problem in stringStream
fparain
parents: 18025
diff changeset
   597
  void set_current_resource_mark(ResourceMark* rm) { _current_resource_mark = rm; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  void check_for_valid_safepoint_state(bool potential_vm_operation) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  volatile int _jvmti_env_iteration_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  void entering_jvmti_env_iteration()            { ++_jvmti_env_iteration_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  void leaving_jvmti_env_iteration()             { --_jvmti_env_iteration_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  bool is_inside_jvmti_env_iteration()           { return _jvmti_env_iteration_count > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  // Code generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  static ByteSize exception_file_offset()        { return byte_offset_of(Thread, _exception_file   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  static ByteSize exception_line_offset()        { return byte_offset_of(Thread, _exception_line   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  static ByteSize active_handles_offset()        { return byte_offset_of(Thread, _active_handles   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  static ByteSize stack_base_offset()            { return byte_offset_of(Thread, _stack_base ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  static ByteSize stack_size_offset()            { return byte_offset_of(Thread, _stack_size ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
#define TLAB_FIELD_OFFSET(name) \
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   619
  static ByteSize tlab_##name##_offset()         { return byte_offset_of(Thread, _tlab) + ThreadLocalAllocBuffer::name##_offset(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  TLAB_FIELD_OFFSET(start)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  TLAB_FIELD_OFFSET(end)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  TLAB_FIELD_OFFSET(top)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  TLAB_FIELD_OFFSET(pf_top)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  TLAB_FIELD_OFFSET(size)                   // desired_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  TLAB_FIELD_OFFSET(refill_waste_limit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  TLAB_FIELD_OFFSET(number_of_refills)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  TLAB_FIELD_OFFSET(fast_refill_waste)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  TLAB_FIELD_OFFSET(slow_allocations)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
#undef TLAB_FIELD_OFFSET
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   633
  static ByteSize allocated_bytes_offset()       { return byte_offset_of(Thread, _allocated_bytes ); }
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7399
diff changeset
   634
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  volatile intptr_t _Stalled ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  volatile int _TypeTag ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  ParkEvent * _ParkEvent ;                     // for synchronized()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  ParkEvent * _SleepEvent ;                    // for Thread.sleep
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  ParkEvent * _MutexEvent ;                    // for native internal Mutex/Monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
  ParkEvent * _MuxEvent ;                      // for low-level muxAcquire-muxRelease
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  int NativeSyncRecursion ;                    // diagnostic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  volatile int _OnTrap ;                       // Resume-at IP delta
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  jint _hashStateW ;                           // Marsaglia Shift-XOR thread-local RNG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  jint _hashStateX ;                           // thread-specific hashCode generator state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  jint _hashStateY ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  jint _hashStateZ ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  void * _schedctl ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  volatile jint rng [4] ;                      // RNG for spin loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // Low-level leaf-lock primitives used to implement synchronization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  // and native monitor-mutex infrastructure.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  // Not for general synchronization use.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  static void SpinAcquire (volatile int * Lock, const char * Name) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  static void SpinRelease (volatile int * Lock) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  static void muxAcquire  (volatile intptr_t * Lock, const char * Name) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  static void muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  static void muxRelease  (volatile intptr_t * Lock) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
// Inline implementation of Thread::current()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
// Thread::current is "hot" it's called > 128K times in the 1st 500 msecs of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
// startup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
// ThreadLocalStorage::thread is warm -- it's called > 16K times in the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
// period.   This is inlined in thread_<os_family>.inline.hpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
inline Thread* Thread::current() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
// This function is very high traffic. Define PARANOID to enable expensive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
// asserts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
#ifdef PARANOID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  // Signal handler should call ThreadLocalStorage::get_thread_slow()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  Thread* t = ThreadLocalStorage::get_thread_slow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  assert(t != NULL && !t->is_inside_signal_handler(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
         "Don't use Thread::current() inside signal handler");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  Thread* thread = ThreadLocalStorage::thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  assert(thread != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  return thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
// Name support for threads.  non-JavaThread subclasses with multiple
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
// uniquely named instances should derive from this.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
class NamedThread: public Thread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    max_name_len = 64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  char* _name;
4489
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   695
  // log JavaThread being processed by oops_do
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   696
  JavaThread* _processed_thread;
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   697
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  NamedThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  ~NamedThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  // May only be called once per thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  void set_name(const char* format, ...);
4489
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   703
  virtual bool is_Named_thread() const { return true; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  virtual char* name() const { return _name == NULL ? (char*)"Unknown Thread" : _name; }
4489
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   705
  JavaThread *processed_thread() { return _processed_thread; }
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 4030
diff changeset
   706
  void set_processed_thread(JavaThread *thread) { _processed_thread = thread; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
// Worker threads are named and have an id of an assigned work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
class WorkerThread: public NamedThread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  uint _id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
public:
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   714
  WorkerThread() : _id(0)               { }
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   715
  virtual bool is_Worker_thread() const { return true; }
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   716
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   717
  virtual WorkerThread* as_Worker_thread() const {
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   718
    assert(is_Worker_thread(), "Dubious cast to WorkerThread*?");
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   719
    return (WorkerThread*) this;
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   720
  }
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   721
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   722
  void set_id(uint work_id)             { _id = work_id; }
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
   723
  uint id() const                       { return _id; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
// A single WatcherThread is used for simulating timer interrupts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
class WatcherThread: public Thread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  static WatcherThread* _watcher_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
14390
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   735
  static bool _startable;
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5920
diff changeset
   736
  volatile static bool _should_terminate; // updated without holding lock
18943
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   737
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   738
  os::WatcherThreadCrashProtection* _crash_protection;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  enum SomeConstants {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    delay_interval = 10                          // interrupt delay in milliseconds
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  WatcherThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  // Tester
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  bool is_Watcher_thread() const                 { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  char* name() const { return (char*)"VM Periodic Task Thread"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  void print() const { print_on(tty); }
14390
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   754
  void unpark();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  // Returns the single instance of WatcherThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  static WatcherThread* watcher_thread()         { return _watcher_thread; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  // Create and start the single instance of WatcherThread, or stop it on shutdown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  static void start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  static void stop();
14390
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   762
  // Only allow start once the VM is sufficiently initialized
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   763
  // Otherwise the first task to enroll will trigger the start
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   764
  static void make_startable();
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   765
18943
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   766
  void set_crash_protection(os::WatcherThreadCrashProtection* crash_protection) {
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   767
    assert(Thread::current()->is_Watcher_thread(), "Can only be set by WatcherThread");
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   768
    _crash_protection = crash_protection;
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   769
  }
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   770
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   771
  bool has_crash_protection() const { return _crash_protection != NULL; }
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   772
  os::WatcherThreadCrashProtection* crash_protection() const { return _crash_protection; }
7d0ef675e808 8020701: Avoid crashes in WatcherThread
rbackman
parents: 18938
diff changeset
   773
14390
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   774
 private:
bd0d881cf1c5 7127792: Add the ability to change an existing PeriodicTask's execution interval
rbackman
parents: 14083
diff changeset
   775
  int sleep() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
class CompilerThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
typedef void (*ThreadFunction)(JavaThread*, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
class JavaThread: public Thread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  JavaThread*    _next;                          // The next thread in the Threads list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  oop            _threadObj;                     // The Java level thread object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  int _java_call_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  int  java_call_counter()                       { return _java_call_counter; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  void inc_java_call_counter()                   { _java_call_counter++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  void dec_java_call_counter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    assert(_java_call_counter > 0, "Invalid nesting of JavaCallWrapper");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    _java_call_counter--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
 private:  // restore original namespace restriction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
#endif  // ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
    jump_ring_buffer_size = 16
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
 private:  // restore original namespace restriction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  JavaFrameAnchor _anchor;                       // Encapsulation of current java frame and it state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  ThreadFunction _entry_point;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  JNIEnv        _jni_environment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  // Deopt support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  DeoptResourceMark*  _deopt_mark;               // Holds special ResourceMark for deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  intptr_t*      _must_deopt_id;                 // id of frame that needs to be deopted once we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
                                                 // transition out of native
6740
2bc601284215 6986270: guarantee(*bcp != Bytecodes::_monitorenter || exec_mode != Deoptimization::Unpack_exception) fails
iveresov
parents: 6184
diff changeset
   822
  nmethod*       _deopt_nmethod;                 // nmethod that is currently being deoptimized
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  vframeArray*  _vframe_array_head;              // Holds the heap of the active vframeArrays
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  vframeArray*  _vframe_array_last;              // Holds last vFrameArray we popped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  // Because deoptimization is lazy we must save jvmti requests to set locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  // in compiled frames until we deoptimize and we have an interpreter frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  // This holds the pointer to array (yeah like there might be more than one) of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  // description of compiled vframes that have locals that need to be updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  GrowableArray<jvmtiDeferredLocalVariableSet*>* _deferred_locals_updates;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  // Handshake value for fixing 6243940. We need a place for the i2c
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   832
  // adapter to store the callee Method*. This value is NEVER live
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  // across a gc point so it does NOT have to be gc'd
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  // The handshake is open ended since we can't be certain that it will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  // be NULLed. This is because we rarely ever see the race and end up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  // in handle_wrong_method which is the backend of the handshake. See
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  // code in i2c adapters and handle_wrong_method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   839
  Method*       _callee_target;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   841
  // Used to pass back results to the interpreter or generated code running Java code.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   842
  oop           _vm_result;    // oop result is GC-preserved
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   843
  Metadata*     _vm_result_2;  // non-oop result
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
   844
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
   845
  // See ReduceInitialCardMarks: this holds the precise space interval of
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
   846
  // the most recent slow path allocation for which compiled code has
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
   847
  // elided card-marks for performance along the fast-path.
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
   848
  MemRegion     _deferred_card_mark;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  MonitorChunk* _monitor_chunks;                 // Contains the off stack monitors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
                                                 // allocated during deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
                                                 // and by JNI_MonitorEnter/Exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  // Async. requests support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  enum AsyncRequests {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
    _no_async_condition = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
    _async_exception,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
    _async_unsafe_access_error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  AsyncRequests _special_runtime_exit_condition; // Enum indicating pending async. request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  oop           _pending_async_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  // Safepoint support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
 public:                                         // Expose _thread_state for SafeFetchInt()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  volatile JavaThreadState _thread_state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  ThreadSafepointState *_safepoint_state;        // Holds information about a thread during a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  address               _saved_exception_pc;     // Saved pc of instruction where last implicit exception happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  // JavaThread termination support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  enum TerminatedTypes {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    _not_terminated = 0xDEAD - 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    _thread_exiting,                             // JavaThread::exit() has been called for this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
    _thread_terminated,                          // JavaThread is removed from thread list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    _vm_exited                                   // JavaThread is still executing native code, but VM is terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
                                                 // only VM_Exit can set _vm_exited
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  // In general a JavaThread's _terminated field transitions as follows:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  //   _not_terminated => _thread_exiting => _thread_terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  // _vm_exited is a special value to cover the case of a JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  // executing native code after the VM itself is terminated.
7897
201a8b00ec91 6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents: 7724
diff changeset
   885
  volatile TerminatedTypes _terminated;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  // suspend/resume support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  volatile bool         _suspend_equivalent;     // Suspend equivalent condition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  jint                  _in_deopt_handler;       // count of deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
                                                 // handlers thread is in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  volatile bool         _doing_unsafe_access;    // Thread may fault due to unsafe access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  bool                  _do_not_unlock_if_synchronized; // Do not unlock the receiver of a synchronized method (since it was
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
                                                 // never locked) when throwing an exception. Used by interpreter only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   894
  // JNI attach states:
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   895
  enum JNIAttachStates {
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   896
    _not_attaching_via_jni = 1,  // thread is not attaching via JNI
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   897
    _attaching_via_jni,          // thread is attaching via JNI
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   898
    _attached_via_jni            // thread has attached via JNI
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   899
  };
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   900
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   901
  // A regular JavaThread's _jni_attach_state is _not_attaching_via_jni.
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   902
  // A native thread that is attaching via JNI starts with a value
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   903
  // of _attaching_via_jni and transitions to _attached_via_jni.
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   904
  volatile JNIAttachStates _jni_attach_state;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  // State of the stack guard pages for this thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  enum StackGuardState {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
    stack_guard_unused,         // not needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
    stack_guard_yellow_disabled,// disabled (temporarily) after stack overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
    stack_guard_enabled         // enabled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
22810
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
   916
  StackGuardState  _stack_guard_state;
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
   917
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
   918
  // Precompute the limit of the stack as used in stack overflow checks.
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
   919
  // We load it from here to simplify the stack overflow check in assembly.
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
   920
  address          _stack_overflow_limit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  // Compiler exception handling (NOTE: The _exception_oop is *NOT* the same as _pending_exception. It is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  // used to temp. parsing values into and out of the runtime system during exception handling for compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  // code)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  volatile oop     _exception_oop;               // Exception thrown in compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  volatile address _exception_pc;                // PC where exception happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  volatile address _exception_handler_pc;        // PC for handler of exception
5252
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 4761
diff changeset
   928
  volatile int     _is_method_handle_return;     // true (== 1) if the current exception PC is a MethodHandle call site.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  // support for JNI critical regions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  jint    _jni_active_critical;                  // count of entries into JNI critical region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  // For deadlock detection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  int _depth_first_number;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  // JVMTI PopFrame support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  // This is set to popframe_pending to signal that top Java frame should be popped immediately
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  int _popframe_condition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  int _jmp_ring_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
      // We use intptr_t instead of address so debugger doesn't try and display strings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
      intptr_t _target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
      intptr_t _instruction;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
      const char*  _file;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
      int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  }   _jmp_ring[ jump_ring_buffer_size ];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
   951
#if INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   952
  // Support for G1 barriers
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   953
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   954
  ObjPtrQueue _satb_mark_queue;          // Thread-local log for SATB barrier.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   955
  // Set of all such queues.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   956
  static SATBMarkQueueSet _satb_mark_queue_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   957
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   958
  DirtyCardQueue _dirty_card_queue;      // Thread-local log for dirty cards.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   959
  // Set of all such queues.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   960
  static DirtyCardQueueSet _dirty_card_queue_set;
1560
1b328492b7f8 6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents: 1374
diff changeset
   961
1b328492b7f8 6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents: 1374
diff changeset
   962
  void flush_barrier_queues();
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
   963
#endif // INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   964
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  friend class VMThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  friend class ThreadWaitTransition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
  friend class VM_Exit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  void initialize();                             // Initialized the instance variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  // Constructor
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   973
  JavaThread(bool is_attaching_via_jni = false); // for main thread and JNI attached threads
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  JavaThread(ThreadFunction entry_point, size_t stack_size = 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  ~JavaThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  // verify this JavaThread hasn't be published in the Threads::list yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  void verify_not_published();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  //JNI functiontable getter/setter for JVMTI jni function table interception API.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
  void set_jni_functions(struct JNINativeInterface_* functionTable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    _jni_environment.functions = functionTable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  struct JNINativeInterface_* get_jni_functions() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    return (struct JNINativeInterface_ *)_jni_environment.functions;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5920
diff changeset
   990
  // This function is called at thread creation to allow
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5920
diff changeset
   991
  // platform specific thread variables to be initialized.
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5920
diff changeset
   992
  void cache_global_variables();
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5920
diff changeset
   993
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  // Executes Shutdown.shutdown()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  void invoke_shutdown_hooks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  // Cleanup on thread exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  enum ExitType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
    normal_exit,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
    jni_detach
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  void exit(bool destroy_vm, ExitType exit_type = normal_exit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  void cleanup_failed_attach_current_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  // Testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  virtual bool is_Java_thread() const            { return true;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  // Thread chain operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  JavaThread* next() const                       { return _next; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  void set_next(JavaThread* p)                   { _next = p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  // Thread oop. threadObj() can be NULL for initial JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  // (or for threads attached via JNI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  oop threadObj() const                          { return _threadObj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  void set_threadObj(oop p)                      { _threadObj = p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  ThreadPriority java_priority() const;          // Read from threadObj()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  // Prepare thread and add to priority queue.  If a priority is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  // not specified, use the priority of the thread object. Threads_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  // must be held while this function is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  void prepare(jobject jni_thread, ThreadPriority prio=NoPriority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  void set_saved_exception_pc(address pc)        { _saved_exception_pc = pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  address saved_exception_pc()                   { return _saved_exception_pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  ThreadFunction entry_point() const             { return _entry_point; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  // Allocates a new Java level thread object for this thread. thread_name may be NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  void allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  // Last frame anchor routines
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
22870
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1036
  JavaFrameAnchor* frame_anchor(void)            { return &_anchor; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  // last_Java_sp
22870
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1039
  bool has_last_Java_frame() const               { return _anchor.has_last_Java_frame(); }
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1040
  intptr_t* last_Java_sp() const                 { return _anchor.last_Java_sp(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  // last_Java_pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
22870
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1044
  address last_Java_pc(void)                     { return _anchor.last_Java_pc(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  // Safepoint support
22870
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1047
#ifndef PPC64
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1048
  JavaThreadState thread_state() const           { return _thread_state; }
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1049
  void set_thread_state(JavaThreadState s)       { _thread_state = s;    }
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1050
#else
22859
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1051
  // Use membars when accessing volatile _thread_state. See
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1052
  // Threads::create_vm() for size checks.
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1053
  JavaThreadState thread_state() const           {
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1054
    return (JavaThreadState) OrderAccess::load_acquire((volatile jint*)&_thread_state);
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1055
  }
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1056
  void set_thread_state(JavaThreadState s)       {
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1057
    OrderAccess::release_store((volatile jint*)&_thread_state, (jint)s);
7b88983393b7 8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents: 22838
diff changeset
  1058
  }
22870
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1059
#endif
f939d9a0440d 8032634: Add #ifdef PPC64 around OrderAccess operations on _thread_state.
goetz
parents: 22859
diff changeset
  1060
  ThreadSafepointState *safepoint_state() const  { return _safepoint_state; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  void set_safepoint_state(ThreadSafepointState *state) { _safepoint_state = state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
  bool is_at_poll_safepoint()                    { return _safepoint_state->is_at_poll_safepoint(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  // thread has called JavaThread::exit() or is terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  bool is_exiting()                              { return _terminated == _thread_exiting || is_terminated(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  // thread is terminated (no longer on the threads list); we compare
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  // against the two non-terminated values so that a freed JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  // will also be considered terminated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  bool is_terminated()                           { return _terminated != _not_terminated && _terminated != _thread_exiting; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  void set_terminated(TerminatedTypes t)         { _terminated = t; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  // special for Threads::remove() which is static:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
  void set_terminated_value()                    { _terminated = _thread_terminated; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  void block_if_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  bool doing_unsafe_access()                     { return _doing_unsafe_access; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  void set_doing_unsafe_access(bool val)         { _doing_unsafe_access = val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  bool do_not_unlock_if_synchronized()             { return _do_not_unlock_if_synchronized; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  void set_do_not_unlock_if_synchronized(bool val) { _do_not_unlock_if_synchronized = val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  1081
#if INCLUDE_NMT
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1082
  // native memory tracking
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1083
  inline MemRecorder* get_recorder() const          { return (MemRecorder*)_recorder; }
16991
aa4978a77e1f 8010151: nsk/regression/b6653214 fails "assert(snapshot != NULL) failed: Worker should not be started"
zgu
parents: 15926
diff changeset
  1084
  inline void         set_recorder(MemRecorder* rc) { _recorder = rc; }
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1085
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1086
 private:
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1087
  // per-thread memory recorder
16991
aa4978a77e1f 8010151: nsk/regression/b6653214 fails "assert(snapshot != NULL) failed: Worker should not be started"
zgu
parents: 15926
diff changeset
  1088
  MemRecorder* volatile _recorder;
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  1089
#endif // INCLUDE_NMT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  // Suspend/resume support for JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  void set_ext_suspended()       { set_suspend_flag (_ext_suspended);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  void clear_ext_suspended()     { clear_suspend_flag(_ext_suspended); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  void java_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  void java_resume();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  int  java_suspend_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  void check_and_wait_while_suspended() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
    assert(JavaThread::current() == this, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
    bool do_self_suspend;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
      // were we externally suspended while we were waiting?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
      do_self_suspend = handle_special_suspend_equivalent_condition();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
      if (do_self_suspend) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
        // don't surprise the thread that suspended us by returning
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
        java_suspend_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
        set_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
    } while (do_self_suspend);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  static void check_safepoint_and_suspend_for_native_trans(JavaThread *thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  // Check for async exception in addition to safepoint and suspend request.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  static void check_special_condition_for_native_trans(JavaThread *thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1119
  // Same as check_special_condition_for_native_trans but finishes the
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1120
  // transition into thread_in_Java mode so that it can potentially
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1121
  // block.
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1122
  static void check_special_condition_for_native_trans_and_transition(JavaThread *thread);
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1123
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  bool is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  bool is_ext_suspend_completed_with_lock(uint32_t *bits) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
    // Warning: is_ext_suspend_completed() may temporarily drop the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
    // SR_lock to allow the thread to reach a stable thread state if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
    // it is currently in a transient thread state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
    return is_ext_suspend_completed(false /*!called_by_wait */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
                                    SuspendRetryDelay, bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  // We cannot allow wait_for_ext_suspend_completion() to run forever or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  // we could hang. SuspendRetryCount and SuspendRetryDelay are normally
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  // passed as the count and delay parameters. Experiments with specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
  // calls to wait_for_ext_suspend_completion() can be done by passing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  // other values in the code. Experiments with all calls can be done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  // via the appropriate -XX options.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  bool wait_for_ext_suspend_completion(int count, int delay, uint32_t *bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  void set_external_suspend()     { set_suspend_flag  (_external_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  void clear_external_suspend()   { clear_suspend_flag(_external_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  void set_deopt_suspend()        { set_suspend_flag  (_deopt_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  void clear_deopt_suspend()      { clear_suspend_flag(_deopt_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  bool is_deopt_suspend()         { return (_suspend_flags & _deopt_suspend) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
  bool is_external_suspend() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
    return (_suspend_flags & _external_suspend) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
  // Whenever a thread transitions from native to vm/java it must suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  // if external|deopt suspend is present.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  bool is_suspend_after_native() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    return (_suspend_flags & (_external_suspend | _deopt_suspend) ) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
  // external suspend request is completed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  bool is_ext_suspended() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
    return (_suspend_flags & _ext_suspended) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
  bool is_external_suspend_with_lock() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
    return is_external_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  // Special method to handle a pending external suspend request
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
  // when a suspend equivalent condition lifts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  bool handle_special_suspend_equivalent_condition() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
    assert(is_suspend_equivalent(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
      "should only be called in a suspend equivalence condition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
    bool ret = is_external_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
    if (!ret) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
      // not about to self-suspend so clear suspend equivalence
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
      clear_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
    // implied else:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
    // We have a pending external suspend request so we leave the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
    // suspend_equivalent flag set until java_suspend_self() sets
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
    // the ext_suspended flag and clears the suspend_equivalent
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
    // flag. This insures that wait_for_ext_suspend_completion()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
    // will return consistent values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  // utility methods to see if we are doing some kind of suspension
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  bool is_being_ext_suspended() const            {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
    return is_ext_suspended() || is_external_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
  bool is_suspend_equivalent() const             { return _suspend_equivalent; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  void set_suspend_equivalent()                  { _suspend_equivalent = true; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  void clear_suspend_equivalent()                { _suspend_equivalent = false; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
  // Thread.stop support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
  void send_thread_stop(oop throwable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
  AsyncRequests clear_special_runtime_exit_condition() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
    AsyncRequests x = _special_runtime_exit_condition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
    _special_runtime_exit_condition = _no_async_condition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
    return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
  // Are any async conditions present?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  bool has_async_condition() { return (_special_runtime_exit_condition != _no_async_condition); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  void check_and_handle_async_exceptions(bool check_unsafe_error = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
  // these next two are also used for self-suspension and async exception support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  void handle_special_runtime_exit_condition(bool check_asyncs = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  // Return true if JavaThread has an asynchronous condition or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  // if external suspension is requested.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  bool has_special_runtime_exit_condition() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    // We call is_external_suspend() last since external suspend should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
    // be less common. Because we don't use is_external_suspend_with_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    // it is possible that we won't see an asynchronous external suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
    // request that has just gotten started, i.e., SR_lock grabbed but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    // _external_suspend field change either not made yet or not visible
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
    // yet. However, this is okay because the request is asynchronous and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
    // we will see the new flag value the next time through. It's also
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
    // possible that the external suspend request is dropped after
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
    // we have checked is_external_suspend(), we will recheck its value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
    // under SR_lock in java_suspend_self().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
    return (_special_runtime_exit_condition != _no_async_condition) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
            is_external_suspend() || is_deopt_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
  void set_pending_unsafe_access_error()          { _special_runtime_exit_condition = _async_unsafe_access_error; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  void set_pending_async_exception(oop e) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
    _pending_async_exception = e;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
    _special_runtime_exit_condition = _async_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
    set_has_async_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  // Fast-locking support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  bool is_lock_owned(address adr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  // Accessors for vframe array top
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
  // The linked list of vframe arrays are sorted on sp. This means when we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  // unpack the head must contain the vframe array to unpack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
  void set_vframe_array_head(vframeArray* value) { _vframe_array_head = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  vframeArray* vframe_array_head() const         { return _vframe_array_head;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 20707
diff changeset
  1249
  // Side structure for deferring update of java frame locals until deopt occurs
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
  GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred_locals() const { return _deferred_locals_updates; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
  void set_deferred_locals(GrowableArray<jvmtiDeferredLocalVariableSet *>* vf) { _deferred_locals_updates = vf; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  // These only really exist to make debugging deopt problems simpler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
  void set_vframe_array_last(vframeArray* value) { _vframe_array_last = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  vframeArray* vframe_array_last() const         { return _vframe_array_last;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  // The special resourceMark used during deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  void set_deopt_mark(DeoptResourceMark* value)  { _deopt_mark = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  DeoptResourceMark* deopt_mark(void)            { return _deopt_mark; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  intptr_t* must_deopt_id()                      { return _must_deopt_id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
  void     set_must_deopt_id(intptr_t* id)       { _must_deopt_id = id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  void     clear_must_deopt_id()                 { _must_deopt_id = NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
6740
2bc601284215 6986270: guarantee(*bcp != Bytecodes::_monitorenter || exec_mode != Deoptimization::Unpack_exception) fails
iveresov
parents: 6184
diff changeset
  1267
  void set_deopt_nmethod(nmethod* nm)            { _deopt_nmethod = nm;   }
2bc601284215 6986270: guarantee(*bcp != Bytecodes::_monitorenter || exec_mode != Deoptimization::Unpack_exception) fails
iveresov
parents: 6184
diff changeset
  1268
  nmethod* deopt_nmethod()                       { return _deopt_nmethod; }
2bc601284215 6986270: guarantee(*bcp != Bytecodes::_monitorenter || exec_mode != Deoptimization::Unpack_exception) fails
iveresov
parents: 6184
diff changeset
  1269
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1270
  Method*    callee_target() const               { return _callee_target; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1271
  void set_callee_target  (Method* x)          { _callee_target   = x; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  // Oop results of vm runtime calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  oop  vm_result() const                         { return _vm_result; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  void set_vm_result  (oop x)                    { _vm_result   = x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1277
  Metadata*    vm_result_2() const               { return _vm_result_2; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1278
  void set_vm_result_2  (Metadata* x)          { _vm_result_2   = x; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
  1280
  MemRegion deferred_card_mark() const           { return _deferred_card_mark; }
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
  1281
  void set_deferred_card_mark(MemRegion mr)      { _deferred_card_mark = mr;   }
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3916
diff changeset
  1282
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  // Exception handling for compiled methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  oop      exception_oop() const                 { return _exception_oop; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  address  exception_pc() const                  { return _exception_pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  address  exception_handler_pc() const          { return _exception_handler_pc; }
5252
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 4761
diff changeset
  1287
  bool     is_method_handle_return() const       { return _is_method_handle_return == 1; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 19696
diff changeset
  1289
  void set_exception_oop(oop o)                  { (void)const_cast<oop&>(_exception_oop = o); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
  void set_exception_pc(address a)               { _exception_pc = a; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  void set_exception_handler_pc(address a)       { _exception_handler_pc = a; }
5252
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 4761
diff changeset
  1292
  void set_is_method_handle_return(bool value)   { _is_method_handle_return = value ? 1 : 0; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
20703
2de7fe0e9693 8005173: assert(false) failed: DEBUG MESSAGE: exception oop must be empty (macroAssembler_x86.cpp:625)
twisti
parents: 20282
diff changeset
  1294
  void clear_exception_oop_and_pc() {
2de7fe0e9693 8005173: assert(false) failed: DEBUG MESSAGE: exception oop must be empty (macroAssembler_x86.cpp:625)
twisti
parents: 20282
diff changeset
  1295
    set_exception_oop(NULL);
2de7fe0e9693 8005173: assert(false) failed: DEBUG MESSAGE: exception oop must be empty (macroAssembler_x86.cpp:625)
twisti
parents: 20282
diff changeset
  1296
    set_exception_pc(NULL);
2de7fe0e9693 8005173: assert(false) failed: DEBUG MESSAGE: exception oop must be empty (macroAssembler_x86.cpp:625)
twisti
parents: 20282
diff changeset
  1297
  }
2de7fe0e9693 8005173: assert(false) failed: DEBUG MESSAGE: exception oop must be empty (macroAssembler_x86.cpp:625)
twisti
parents: 20282
diff changeset
  1298
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  // Stack overflow support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
  inline size_t stack_available(address cur_sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
  address stack_yellow_zone_base()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
    { return (address)(stack_base() - (stack_size() - (stack_red_zone_size() + stack_yellow_zone_size()))); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
  size_t  stack_yellow_zone_size()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
    { return StackYellowPages * os::vm_page_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
  address stack_red_zone_base()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
    { return (address)(stack_base() - (stack_size() - stack_red_zone_size())); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  size_t stack_red_zone_size()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
    { return StackRedPages * os::vm_page_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
  bool in_stack_yellow_zone(address a)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
    { return (a <= stack_yellow_zone_base()) && (a >= stack_red_zone_base()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  bool in_stack_red_zone(address a)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
    { return (a <= stack_red_zone_base()) && (a >= (address)((intptr_t)stack_base() - stack_size())); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  void create_stack_guard_pages();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  void remove_stack_guard_pages();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  void enable_stack_yellow_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  void disable_stack_yellow_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  void enable_stack_red_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
  void disable_stack_red_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
15926
8e87d545195f 7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents: 15482
diff changeset
  1322
  inline bool stack_guard_zone_unused();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  inline bool stack_yellow_zone_disabled();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  inline bool stack_yellow_zone_enabled();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
  // Attempt to reguard the stack after a stack overflow may have occurred.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  // Returns true if (a) guard pages are not needed on this thread, (b) the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  // pages are already guarded, or (c) the pages were successfully reguarded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  // Returns false if there is not enough stack space to reguard the pages, in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
  // which case the caller should unwind a frame and try again.  The argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  // should be the caller's (approximate) sp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  bool reguard_stack(address cur_sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  // Similar to above but see if current stackpoint is out of the guard area
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  // and reguard if possible.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  bool reguard_stack(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
22810
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1337
  address stack_overflow_limit() { return _stack_overflow_limit; }
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1338
  void set_stack_overflow_limit() {
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1339
    _stack_overflow_limit = _stack_base - _stack_size +
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1340
                            ((StackShadowPages +
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1341
                              StackYellowPages +
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1342
                              StackRedPages) * os::vm_page_size());
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1343
  }
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1344
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
  // Misc. accessors/mutators
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  void set_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  void clr_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
  bool do_not_unlock(void)                       { return _do_not_unlock_if_synchronized; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
  void record_jump(address target, address instr, const char* file, int line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  // For assembly stub generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  static ByteSize threadObj_offset()             { return byte_offset_of(JavaThread, _threadObj           ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
  static ByteSize jmp_ring_index_offset()        { return byte_offset_of(JavaThread, _jmp_ring_index      ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  static ByteSize jmp_ring_offset()              { return byte_offset_of(JavaThread, _jmp_ring            ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  static ByteSize jni_environment_offset()       { return byte_offset_of(JavaThread, _jni_environment     ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  static ByteSize last_Java_sp_offset()          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_sp_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  static ByteSize last_Java_pc_offset()          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_pc_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  static ByteSize frame_anchor_offset()          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
    return byte_offset_of(JavaThread, _anchor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  static ByteSize callee_target_offset()         { return byte_offset_of(JavaThread, _callee_target       ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  static ByteSize vm_result_offset()             { return byte_offset_of(JavaThread, _vm_result           ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  static ByteSize vm_result_2_offset()           { return byte_offset_of(JavaThread, _vm_result_2         ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  static ByteSize thread_state_offset()          { return byte_offset_of(JavaThread, _thread_state        ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  static ByteSize saved_exception_pc_offset()    { return byte_offset_of(JavaThread, _saved_exception_pc  ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
  static ByteSize osthread_offset()              { return byte_offset_of(JavaThread, _osthread            ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  static ByteSize exception_oop_offset()         { return byte_offset_of(JavaThread, _exception_oop       ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  static ByteSize exception_pc_offset()          { return byte_offset_of(JavaThread, _exception_pc        ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
  static ByteSize exception_handler_pc_offset()  { return byte_offset_of(JavaThread, _exception_handler_pc); }
22810
3a4dae5224c7 8017313: PPC64 (part 6): stack handling improvements
goetz
parents: 18025
diff changeset
  1379
  static ByteSize stack_overflow_limit_offset()  { return byte_offset_of(JavaThread, _stack_overflow_limit); }
5252
58f23871a5b6 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 4761
diff changeset
  1380
  static ByteSize is_method_handle_return_offset() { return byte_offset_of(JavaThread, _is_method_handle_return); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  static ByteSize stack_guard_state_offset()     { return byte_offset_of(JavaThread, _stack_guard_state   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
  static ByteSize suspend_flags_offset()         { return byte_offset_of(JavaThread, _suspend_flags       ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  static ByteSize do_not_unlock_if_synchronized_offset() { return byte_offset_of(JavaThread, _do_not_unlock_if_synchronized); }
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1385
  static ByteSize should_post_on_exceptions_flag_offset() {
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1386
    return byte_offset_of(JavaThread, _should_post_on_exceptions_flag);
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1387
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1389
#if INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1390
  static ByteSize satb_mark_queue_offset()       { return byte_offset_of(JavaThread, _satb_mark_queue); }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1391
  static ByteSize dirty_card_queue_offset()      { return byte_offset_of(JavaThread, _dirty_card_queue); }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1392
#endif // INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1393
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
  // Returns the jni environment for this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
  JNIEnv* jni_environment()                      { return &_jni_environment; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  static JavaThread* thread_from_jni_environment(JNIEnv* env) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
    JavaThread *thread_from_jni_env = (JavaThread*)((intptr_t)env - in_bytes(jni_environment_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
    // Only return NULL if thread is off the thread list; starting to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
    // exit should not return NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
    if (thread_from_jni_env->is_terminated()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
       thread_from_jni_env->block_if_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
       return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
       return thread_from_jni_env;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  // JNI critical regions. These can nest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
  bool in_critical()    { return _jni_active_critical > 0; }
11631
33813f69207b 7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents: 11480
diff changeset
  1411
  bool in_last_critical()  { return _jni_active_critical == 1; }
11637
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1412
  void enter_critical() { assert(Thread::current() == this ||
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1413
                                 Thread::current()->is_VM_thread() && SafepointSynchronize::is_synchronizing(),
030466036615 7013347: allow crypto functions to be called inline to enhance performance
never
parents: 11631
diff changeset
  1414
                                 "this must be current thread or synchronizing");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
                          _jni_active_critical++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  void exit_critical()  { assert(Thread::current() == this,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
                                 "this must be current thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
                          _jni_active_critical--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
                          assert(_jni_active_critical >= 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
                                 "JNI critical nesting problem?"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
  // For deadlock detection
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
  int depth_first_number() { return _depth_first_number; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
  void set_depth_first_number(int dfn) { _depth_first_number = dfn; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
  void set_monitor_chunks(MonitorChunk* monitor_chunks) { _monitor_chunks = monitor_chunks; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
  MonitorChunk* monitor_chunks() const           { return _monitor_chunks; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
  void add_monitor_chunk(MonitorChunk* chunk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
  void remove_monitor_chunk(MonitorChunk* chunk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
  bool in_deopt_handler() const                  { return _in_deopt_handler > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
  void inc_in_deopt_handler()                    { _in_deopt_handler++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
  void dec_in_deopt_handler()                    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    assert(_in_deopt_handler > 0, "mismatched deopt nesting");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
    if (_in_deopt_handler > 0) { // robustness
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
      _in_deopt_handler--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
  void set_entry_point(ThreadFunction entry_point) { _entry_point = entry_point; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
  // Frame iteration; calls the function f for all frames on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
  void frames_do(void f(frame*, const RegisterMap*));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
  // Memory operations
14582
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
  1451
  void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
  // Sweeper operations
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
  1454
  void nmethods_do(CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1456
  // RedefineClasses Support
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1457
  void metadata_do(void f(Metadata*));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1458
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
  // Memory management operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
  void gc_epilogue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
  void gc_prologue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
  // Misc. operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
  char* name() const { return (char*)get_thread_name(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
  void print() const { print_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
  void print_value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
  void print_thread_state_on(outputStream* ) const      PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
  void print_thread_state() const                       PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
  void print_on_error(outputStream* st, char* buf, int buflen) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  void verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
  const char* get_thread_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
  // factor out low-level mechanics for use in both normal and error cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
  const char* get_thread_name_string(char* buf = NULL, int buflen = 0) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
  const char* get_threadgroup_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
  const char* get_parent_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
  // Accessing frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
  frame last_frame() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
    _anchor.make_walkable(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
    return pd_last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
  javaVFrame* last_java_vframe(RegisterMap* reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
  // Returns method at 'depth' java or native frames down the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  // Used for security checks
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1489
  Klass* security_get_caller_class(int depth);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
  // Print stack trace in external format
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
  void print_stack_on(outputStream* st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  void print_stack() { print_stack_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
  // Print stack traces in various internal formats
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
  void trace_stack()                             PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
  void trace_stack_from(vframe* start_vf)        PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
  void trace_frames()                            PRODUCT_RETURN;
10517
f92c9ff3a15f 7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents: 10508
diff changeset
  1499
  void trace_oops()                              PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8110
diff changeset
  1501
  // Print an annotated view of the stack frames
9942
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1502
  void print_frame_layout(int depth = 0, bool validate_only = false) NOT_DEBUG_RETURN;
9437
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8110
diff changeset
  1503
  void validate_frame_layout() {
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8110
diff changeset
  1504
    print_frame_layout(0, true);
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8110
diff changeset
  1505
  }
9981851b4b8c 7009361: JSR 292 Invalid value on stack on solaris-sparc with -Xcomp
never
parents: 8110
diff changeset
  1506
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
  // Returns the number of stack frames on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
  int depth() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
  // Function for testing deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  void deoptimize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  void make_zombies();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
  void deoptimized_wrt_marked_nmethods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  // Profiling operation (see fprofile.cpp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
   bool profile_last_Java_frame(frame* fr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
   ThreadProfiler* _thread_profiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
   friend class FlatProfiler;                    // uses both [gs]et_thread_profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
   friend class FlatProfilerTask;                // uses get_thread_profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
   friend class ThreadProfilerMark;              // uses get_thread_profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
   ThreadProfiler* get_thread_profiler()         { return _thread_profiler; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
   ThreadProfiler* set_thread_profiler(ThreadProfiler* tp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
     ThreadProfiler* result = _thread_profiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
     _thread_profiler = tp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
     return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1533
 // NMT (Native memory tracking) support.
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1534
 // This flag helps NMT to determine if this JavaThread will be blocked
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1535
 // at safepoint. If not, ThreadCritical is needed for writing memory records.
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1536
 // JavaThread is only safepoint visible when it is in Threads' thread list,
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1537
 // it is not visible until it is added to the list and becomes invisible
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1538
 // once it is removed from the list.
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1539
 public:
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1540
  bool is_safepoint_visible() const { return _safepoint_visible; }
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1541
  void set_safepoint_visible(bool visible) { _safepoint_visible = visible; }
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1542
 private:
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1543
  bool _safepoint_visible;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12108
diff changeset
  1544
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
  // Static operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
  // Returns the running thread as a JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
  static inline JavaThread* current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
  // Returns the active Java thread.  Do not use this if you know you are calling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
  // from a JavaThread, as it's slower than JavaThread::current.  If called from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
  // the VMThread, it also returns the JavaThread that instigated the VMThread's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
  // operation.  You may not want that either.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
  static JavaThread* active();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
  inline CompilerThread* as_CompilerThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
  void thread_main_inner();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
  // PRIVILEGED STACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  PrivilegedElement*  _privileged_stack_top;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  GrowableArray<oop>* _array_for_gc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  // Returns the privileged_stack information.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
  PrivilegedElement* privileged_stack_top() const       { return _privileged_stack_top; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
  void set_privileged_stack_top(PrivilegedElement *e)   { _privileged_stack_top = e; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  void register_array_for_gc(GrowableArray<oop>* array) { _array_for_gc = array; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  // Thread local information maintained by JVMTI.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
  void set_jvmti_thread_state(JvmtiThreadState *value)                           { _jvmti_thread_state = value; }
2135
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1576
  // A JvmtiThreadState is lazily allocated. This jvmti_thread_state()
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1577
  // getter is used to get this JavaThread's JvmtiThreadState if it has
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1578
  // one which means NULL can be returned. JvmtiThreadState::state_for()
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1579
  // is used to get the specified JavaThread's JvmtiThreadState if it has
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1580
  // one or it allocates a new JvmtiThreadState for the JavaThread and
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1581
  // returns it. JvmtiThreadState::state_for() will return NULL only if
f82c3012ec86 6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents: 1623
diff changeset
  1582
  // the specified JavaThread is exiting.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
  JvmtiThreadState *jvmti_thread_state() const                                   { return _jvmti_thread_state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
  static ByteSize jvmti_thread_state_offset()                                    { return byte_offset_of(JavaThread, _jvmti_thread_state); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
  void set_jvmti_get_loaded_classes_closure(JvmtiGetLoadedClassesClosure* value) { _jvmti_get_loaded_classes_closure = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
  JvmtiGetLoadedClassesClosure* get_jvmti_get_loaded_classes_closure() const     { return _jvmti_get_loaded_classes_closure; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
  // JVMTI PopFrame support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
  // Setting and clearing popframe_condition
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  // All of these enumerated values are bits. popframe_pending
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  // indicates that a PopFrame() has been requested and not yet been
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
  // completed. popframe_processing indicates that that PopFrame() is in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
  // the process of being completed. popframe_force_deopt_reexecution_bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
  // indicates that special handling is required when returning to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
  // deoptimized caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  enum PopCondition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
    popframe_inactive                      = 0x00,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
    popframe_pending_bit                   = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
    popframe_processing_bit                = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
    popframe_force_deopt_reexecution_bit   = 0x04
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
  PopCondition popframe_condition()                   { return (PopCondition) _popframe_condition; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
  void set_popframe_condition(PopCondition c)         { _popframe_condition = c; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
  void set_popframe_condition_bit(PopCondition c)     { _popframe_condition |= c; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
  void clear_popframe_condition()                     { _popframe_condition = popframe_inactive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
  static ByteSize popframe_condition_offset()         { return byte_offset_of(JavaThread, _popframe_condition); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
  bool has_pending_popframe()                         { return (popframe_condition() & popframe_pending_bit) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
  bool popframe_forcing_deopt_reexecution()           { return (popframe_condition() & popframe_force_deopt_reexecution_bit) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
  void clear_popframe_forcing_deopt_reexecution()     { _popframe_condition &= ~popframe_force_deopt_reexecution_bit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
  bool pop_frame_pending(void)                        { return ((_popframe_condition & popframe_pending_bit) != 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
  void clr_pop_frame_pending(void)                    { _popframe_condition = popframe_inactive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
  bool pop_frame_in_process(void)                     { return ((_popframe_condition & popframe_processing_bit) != 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  void set_pop_frame_in_process(void)                 { _popframe_condition |= popframe_processing_bit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
  void clr_pop_frame_in_process(void)                 { _popframe_condition &= ~popframe_processing_bit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  // Saved incoming arguments to popped frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
  // Used only when popped interpreted frame returns to deoptimized frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  void*    _popframe_preserved_args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
  int      _popframe_preserved_args_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
  void  popframe_preserve_args(ByteSize size_in_bytes, void* start);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  void* popframe_preserved_args();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  ByteSize popframe_preserved_args_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  WordSize popframe_preserved_args_size_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  void  popframe_free_preserved_args();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
  JvmtiThreadState *_jvmti_thread_state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
  JvmtiGetLoadedClassesClosure* _jvmti_get_loaded_classes_closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
  // Used by the interpreter in fullspeed mode for frame pop, method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
  // entry, method exit and single stepping support. This field is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
  // only set to non-zero by the VM_EnterInterpOnlyMode VM operation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  // It can be set to zero asynchronously (i.e., without a VM operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
  // or a lock) so we have to be very careful.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  int               _interp_only_mode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
  // used by the interpreter for fullspeed debugging support (see above)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
  static ByteSize interp_only_mode_offset() { return byte_offset_of(JavaThread, _interp_only_mode); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
  bool is_interp_only_mode()                { return (_interp_only_mode != 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  int get_interp_only_mode()                { return _interp_only_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
  void increment_interp_only_mode()         { ++_interp_only_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
  void decrement_interp_only_mode()         { --_interp_only_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1651
  // support for cached flag that indicates whether exceptions need to be posted for this thread
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1652
  // if this is false, we can avoid deoptimizing when events are thrown
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1653
  // this gets set to reflect whether jvmtiExport::post_exception_throw would actually do anything
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1654
 private:
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1655
  int    _should_post_on_exceptions_flag;
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1656
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1657
 public:
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1658
  int   should_post_on_exceptions_flag()  { return _should_post_on_exceptions_flag; }
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1659
  void  set_should_post_on_exceptions_flag(int val)  { _should_post_on_exceptions_flag = val; }
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4573
diff changeset
  1660
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
  ThreadStatistics *_thread_stat;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
  ThreadStatistics* get_thread_stat() const    { return _thread_stat; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  // Return a blocker object for which this thread is blocked parking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
  oop current_park_blocker();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
  static size_t _stack_size_at_create;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
  static inline size_t stack_size_at_create(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
    return _stack_size_at_create;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
  static inline void set_stack_size_at_create(size_t value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
    _stack_size_at_create = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1681
#if INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1682
  // SATB marking queue support
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1683
  ObjPtrQueue& satb_mark_queue() { return _satb_mark_queue; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1684
  static SATBMarkQueueSet& satb_mark_queue_set() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1685
    return _satb_mark_queue_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1686
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1687
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1688
  // Dirty card queue support
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1689
  DirtyCardQueue& dirty_card_queue() { return _dirty_card_queue; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1690
  static DirtyCardQueueSet& dirty_card_queue_set() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1691
    return _dirty_card_queue_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1692
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1693
#endif // INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1694
6768
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1695
  // This method initializes the SATB and dirty card queues before a
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1696
  // JavaThread is added to the Java thread list. Right now, we don't
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1697
  // have to do anything to the dirty card queue (it should have been
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1698
  // activated when the thread was created), but we have to activate
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1699
  // the SATB queue if the thread is created while a marking cycle is
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1700
  // in progress. The activation / de-activation of the SATB queues at
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1701
  // the beginning / end of a marking cycle is done during safepoints
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1702
  // so we have to make sure this method is called outside one to be
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1703
  // able to safely read the active field of the SATB queue set. Right
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1704
  // now, it is called just before the thread is added to the Java
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1705
  // thread list in the Threads::add() method. That method is holding
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1706
  // the Threads_lock which ensures we are outside a safepoint. We
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1707
  // cannot do the obvious and set the active field of the SATB queue
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1708
  // when the thread is created given that, in some cases, safepoints
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1709
  // might happen between the JavaThread constructor being called and the
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1710
  // thread being added to the Java thread list (an example of this is
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1711
  // when the structure for the DestroyJavaVM thread is created).
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1712
#if INCLUDE_ALL_GCS
6768
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1713
  void initialize_queues();
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1714
#else  // INCLUDE_ALL_GCS
6768
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1715
  void initialize_queues() { }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14582
diff changeset
  1716
#endif // INCLUDE_ALL_GCS
6768
71338ecb7813 6980838: G1: guarantee(false) failed: thread has an unexpected active value in its SATB queue
tonyp
parents: 6184
diff changeset
  1717
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
  // Machine dependent stuff
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1719
#ifdef TARGET_OS_ARCH_linux_x86
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1720
# include "thread_linux_x86.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1721
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1722
#ifdef TARGET_OS_ARCH_linux_sparc
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1723
# include "thread_linux_sparc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1724
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1725
#ifdef TARGET_OS_ARCH_linux_zero
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1726
# include "thread_linux_zero.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1727
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1728
#ifdef TARGET_OS_ARCH_solaris_x86
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1729
# include "thread_solaris_x86.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1730
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1731
#ifdef TARGET_OS_ARCH_solaris_sparc
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1732
# include "thread_solaris_sparc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1733
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1734
#ifdef TARGET_OS_ARCH_windows_x86
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1735
# include "thread_windows_x86.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1736
#endif
8107
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 7897
diff changeset
  1737
#ifdef TARGET_OS_ARCH_linux_arm
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 7897
diff changeset
  1738
# include "thread_linux_arm.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 7897
diff changeset
  1739
#endif
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 7897
diff changeset
  1740
#ifdef TARGET_OS_ARCH_linux_ppc
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 7897
diff changeset
  1741
# include "thread_linux_ppc.hpp"
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 7897
diff changeset
  1742
#endif
22827
07d991d45a51 8023033: PPC64 (part 13): basic changes for AIX
goetz
parents: 22823
diff changeset
  1743
#ifdef TARGET_OS_ARCH_aix_ppc
07d991d45a51 8023033: PPC64 (part 13): basic changes for AIX
goetz
parents: 22823
diff changeset
  1744
# include "thread_aix_ppc.hpp"
07d991d45a51 8023033: PPC64 (part 13): basic changes for AIX
goetz
parents: 22823
diff changeset
  1745
#endif
10565
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 10517
diff changeset
  1746
#ifdef TARGET_OS_ARCH_bsd_x86
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 10517
diff changeset
  1747
# include "thread_bsd_x86.hpp"
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 10517
diff changeset
  1748
#endif
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 10517
diff changeset
  1749
#ifdef TARGET_OS_ARCH_bsd_zero
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 10517
diff changeset
  1750
# include "thread_bsd_zero.hpp"
dc90c239f4ec 7089790: integrate bsd-port changes
never
parents: 10517
diff changeset
  1751
#endif
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  1752
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
  void set_blocked_on_compilation(bool value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
    _blocked_on_compilation = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
  bool blocked_on_compilation() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
    return _blocked_on_compilation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
  bool         _blocked_on_compilation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  // JSR166 per-thread parker
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  Parker*    _parker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
  Parker*     parker() { return _parker; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  // Biased locking support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  GrowableArray<MonitorInfo*>* _cached_monitor_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
  GrowableArray<MonitorInfo*>* cached_monitor_info() { return _cached_monitor_info; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
  void set_cached_monitor_info(GrowableArray<MonitorInfo*>* info) { _cached_monitor_info = info; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
  // clearing/querying jni attach status
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1780
  bool is_attaching_via_jni() const { return _jni_attach_state == _attaching_via_jni; }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1781
  bool has_attached_via_jni() const { return is_attaching_via_jni() || _jni_attach_state == _attached_via_jni; }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1782
  void set_done_attaching_via_jni() { _jni_attach_state = _attached_via_jni; OrderAccess::fence(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1783
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1784
  // This field is used to determine if a thread has claimed
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1785
  // a par_id: it is -1 if the thread has not claimed a par_id;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1786
  // otherwise its value is the par_id that has been claimed.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1787
  int _claimed_par_id;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1788
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1789
  int get_claimed_par_id() { return _claimed_par_id; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1790
  void set_claimed_par_id(int id) { _claimed_par_id = id;}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
// Inline implementation of JavaThread::current
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
inline JavaThread* JavaThread::current() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  Thread* thread = ThreadLocalStorage::thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  assert(thread != NULL && thread->is_Java_thread(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
  return (JavaThread*)thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
inline CompilerThread* JavaThread::as_CompilerThread() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
  assert(is_Compiler_thread(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
  return (CompilerThread*)this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
15926
8e87d545195f 7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents: 15482
diff changeset
  1805
inline bool JavaThread::stack_guard_zone_unused() {
8e87d545195f 7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents: 15482
diff changeset
  1806
  return _stack_guard_state == stack_guard_unused;
8e87d545195f 7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents: 15482
diff changeset
  1807
}
8e87d545195f 7107135: Stack guard pages are no more protected after loading a shared library with executable stack
iklam
parents: 15482
diff changeset
  1808
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
inline bool JavaThread::stack_yellow_zone_disabled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  return _stack_guard_state == stack_guard_yellow_disabled;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
inline bool JavaThread::stack_yellow_zone_enabled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
  if (os::uses_stack_guard_pages()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
    assert(_stack_guard_state != stack_guard_unused, "guard pages must be in use");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
    return _stack_guard_state == stack_guard_enabled;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
inline size_t JavaThread::stack_available(address cur_sp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
  // This code assumes java stacks grow down
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  address low_addr; // Limit on the address for deepest stack depth
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
  if ( _stack_guard_state == stack_guard_unused) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
    low_addr =  stack_base() - stack_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
    low_addr = stack_yellow_zone_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  return cur_sp > low_addr ? cur_sp - low_addr : 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
// A thread used for Compilation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
class CompilerThread : public JavaThread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
  CompilerCounters* _counters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
20707
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1839
  ciEnv*            _env;
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1840
  CompileLog*       _log;
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1841
  CompileTask*      _task;
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1842
  CompileQueue*     _queue;
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1843
  BufferBlob*       _buffer_blob;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
20707
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1845
  nmethod*          _scanned_nmethod;  // nmethod being scanned by the sweeper
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1846
  AbstractCompiler* _compiler;
9942
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1847
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  static CompilerThread* current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
  CompilerThread(CompileQueue* queue, CompilerCounters* counters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
  bool is_Compiler_thread() const                { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
  // Hide this compiler thread from external view.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  bool is_hidden_from_external_view() const      { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
20707
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1858
  void set_compiler(AbstractCompiler* c)         { _compiler = c; }
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1859
  AbstractCompiler* compiler() const             { return _compiler; }
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1860
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1861
  CompileQueue* queue()        const             { return _queue; }
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1862
  CompilerCounters* counters() const             { return _counters; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  // Get/set the thread's compilation environment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
  ciEnv*        env()                            { return _env; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  void          set_env(ciEnv* env)              { _env = env; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
20707
b3b658c6d1f8 8023014: CodeSweeperSweepNoFlushTest.java fails with HS crash
anoll
parents: 20703
diff changeset
  1868
  BufferBlob*   get_buffer_blob() const          { return _buffer_blob; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1869
  void          set_buffer_blob(BufferBlob* b)   { _buffer_blob = b; };
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1870
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
  // Get/set the thread's logging information
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
  CompileLog*   log()                            { return _log; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  void          init_log(CompileLog* log) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
    // Set once, for good.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
    assert(_log == NULL, "set only once");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
    _log = log;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
9942
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1879
  // GC support
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1880
  // Apply "f->do_oop" to all root oops in "this".
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1881
  // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames
14582
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
  1882
  void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
9942
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1883
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
  IdealGraphPrinter *_ideal_graph_printer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
  IdealGraphPrinter *ideal_graph_printer()                       { return _ideal_graph_printer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
  void set_ideal_graph_printer(IdealGraphPrinter *n)             { _ideal_graph_printer = n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
  // Get/set the thread's current task
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
  CompileTask*  task()                           { return _task; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
  void          set_task(CompileTask* task)      { _task = task; }
9942
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1895
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1896
  // Track the nmethod currently being scanned by the sweeper
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1897
  void          set_scanned_nmethod(nmethod* nm) {
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1898
    assert(_scanned_nmethod == NULL || nm == NULL, "should reset to NULL before writing a new value");
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1899
    _scanned_nmethod = nm;
2e86734ba620 6996747: SIGSEGV in nmethod::cleanup_inline_caches / CompiledIC::verify
never
parents: 9437
diff changeset
  1900
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
inline CompilerThread* CompilerThread::current() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
  return JavaThread::current()->as_CompilerThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
// The active thread queue. It also keeps track of the current used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
// thread priorities.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
class Threads: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
  static JavaThread* _thread_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
  static int         _number_of_threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
  static int         _number_of_non_daemon_threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
  static int         _return_code;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1917
#ifdef ASSERT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1918
  static bool        _vm_complete;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1919
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
22539
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 20707
diff changeset
  1921
  static void initialize_java_lang_classes(JavaThread* main_thread, TRAPS);
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 20707
diff changeset
  1922
  static void initialize_jsr292_core_classes(TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
  // Thread management
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
  // force_daemon is a concession to JNI, where we may need to add a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
  // thread to the thread list before allocating its thread object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
  static void add(JavaThread* p, bool force_daemon = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
  static void remove(JavaThread* p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
  static bool includes(JavaThread* p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
  static JavaThread* first()                     { return _thread_list; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
  static void threads_do(ThreadClosure* tc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
  // Initializes the vm and creates the vm thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
  static jint create_vm(JavaVMInitArgs* args, bool* canTryAgain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
  static void convert_vm_init_libraries_to_agents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
  static void create_vm_init_libraries();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
  static void create_vm_init_agents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
  static void shutdown_vm_agents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
  static bool destroy_vm();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
  // Supported VM versions via JNI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
  // Includes JNI_VERSION_1_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
  static jboolean is_supported_jni_version_including_1_1(jint version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
  // Does not include JNI_VERSION_1_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
  static jboolean is_supported_jni_version(jint version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
  // Garbage collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
  static void follow_other_roots(void f(oop*));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
  // Apply "f->do_oop" to all root oops in all threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
  // This version may only be called by sequential code.
14582
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
  1951
  static void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
  // This version may be called by sequential or parallel code.
14582
490bb6c0df7c 8003720: NPG: Method in interpreter stack frame can be deallocated
stefank
parents: 14390
diff changeset
  1953
  static void possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
  // This creates a list of GCTasks, one per thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
  static void create_thread_roots_tasks(GCTaskQueue* q);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
  // This creates a list of GCTasks, one per thread, for marking objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
  static void create_thread_roots_marking_tasks(GCTaskQueue* q);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
  // Apply "f->do_oop" to roots in all threads that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
  // are part of compiled frames
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
  1961
  static void compiled_frame_oops_do(OopClosure* f, CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
  static void convert_hcode_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
  static void restore_hcode_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
  // Sweeper
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3261
diff changeset
  1967
  static void nmethods_do(CodeBlobClosure* cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1969
  // RedefineClasses support
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1970
  static void metadata_do(void f(Metadata*));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1971
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
  static void gc_epilogue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
  static void gc_prologue();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1974
#ifdef ASSERT
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1975
  static bool is_vm_complete() { return _vm_complete; }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1976
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
  // Verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
  static void verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
  static void print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
  static void print(bool print_stacks, bool internal_format) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
    // this function is only used by debug.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
    print_on(tty, print_stacks, internal_format, false /* no concurrent lock printed */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
  static void print_on_error(outputStream* st, Thread* current, char* buf, int buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
  // Get Java threads that are waiting to enter a monitor. If doLock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
  // is true, then Threads_lock is grabbed as needed. Otherwise, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  // VM needs to be at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
  static GrowableArray<JavaThread*>* get_pending_threads(int count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
    address monitor, bool doLock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  // Get owning Java thread from the monitor's owner field. If doLock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  // is true, then Threads_lock is grabbed as needed. Otherwise, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
  // VM needs to be at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
  static JavaThread *owning_thread_from_monitor_owner(address owner,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
    bool doLock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
  // Number of threads on the active threads list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
  static int number_of_threads()                 { return _number_of_threads; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
  // Number of non-daemon threads on the active threads list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
  static int number_of_non_daemon_threads()      { return _number_of_non_daemon_threads; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
  // Deoptimizes all frames tied to marked nmethods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
  static void deoptimized_wrt_marked_nmethods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
// Thread iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
class ThreadClosure: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  virtual void do_thread(Thread* thread) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
class SignalHandlerMark: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  Thread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  SignalHandlerMark(Thread* t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
    _thread = t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
    if (_thread) _thread->enter_signal_handler();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
  ~SignalHandlerMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
    if (_thread) _thread->leave_signal_handler();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
    _thread = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  2030
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
  2031
#endif // SHARE_VM_RUNTIME_THREAD_HPP