hotspot/src/share/vm/runtime/thread.hpp
author dcubed
Tue, 22 Sep 2009 21:12:37 -0600
changeset 3826 67b89f5a5cac
parent 3261 c7d5aae8d3f7
child 3916 9acd7f9d4f52
permissions -rw-r--r--
6876794: 4/4 sp07t002 hangs very intermittently Summary: remove over locking by VMThread on "is thread suspended?" check Reviewed-by: dholmes, acorn, andrew
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
3261
c7d5aae8d3f7 6862919: Update copyright year
xdono
parents: 2995
diff changeset
     2
 * Copyright 1997-2009 Sun Microsystems, Inc.  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
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
class ThreadSafepointState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
class ThreadProfiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
class JvmtiThreadState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
class JvmtiGetLoadedClassesClosure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
class ThreadStatistics;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
class ConcurrentLocksDump;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
class ParkEvent ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
class ciEnv;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
class CompileThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
class CompileLog;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
class CompileTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
class CompileQueue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
class CompilerCounters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
class vframeArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
class DeoptResourceMark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
class jvmtiDeferredLocalVariableSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class GCTaskQueue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
class ThreadClosure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
class IdealGraphPrinter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// Class hierarchy
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// - Thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
//   - VMThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//   - JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
//   - WatcherThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
class Thread: public ThreadShadow {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  // Exception handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  // (Note: _pending_exception and friends are in ThreadShadow)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  //oop       _pending_exception;                // pending exception for current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  // const char* _exception_file;                   // file information for exception (debugging only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // int         _exception_line;                   // line information for exception (debugging only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  // Support for forcing alignment of thread objects for biased locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  void*       _real_malloc_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  void* operator new(size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  void  operator delete(void* p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // ***************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // Suspend and resume support
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // ***************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // VM suspend/resume no longer exists - it was once used for various
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // things including safepoints but was deprecated and finally removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // in Java 7. Because VM suspension was considered "internal" Java-level
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  // suspension was considered "external", and this legacy naming scheme
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // remains.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // External suspend/resume requests come from JVM_SuspendThread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // JVM_ResumeThread, JVMTI SuspendThread, and finally JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // ResumeThread. External
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  // suspend requests cause _external_suspend to be set and external
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // resume requests cause _external_suspend to be cleared.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  // External suspend requests do not nest on top of other external
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // suspend requests. The higher level APIs reject suspend requests
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // for already suspended threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // The external_suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // flag is checked by has_special_runtime_exit_condition() and java thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // will self-suspend when handle_special_runtime_exit_condition() is
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // called. Most uses of the _thread_blocked state in JavaThreads are
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // considered the same as being externally suspended; if the blocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // condition lifts, the JavaThread will self-suspend. Other places
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // where VM checks for external_suspend include:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  //   + mutex granting (do not enter monitors when thread is suspended)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  //   + state transitions from _thread_in_native
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // In general, java_suspend() does not wait for an external suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // request to complete. When it returns, the only guarantee is that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // the _external_suspend field is true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // wait_for_ext_suspend_completion() is used to wait for an external
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // suspend request to complete. External suspend requests are usually
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // followed by some other interface call that requires the thread to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // be quiescent, e.g., GetCallTrace(). By moving the "wait time" into
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // the interface that requires quiescence, we give the JavaThread a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // chance to self-suspend before we need it to be quiescent. This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // improves overall suspend/query performance.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // _suspend_flags controls the behavior of java_ suspend/resume.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  // It must be set under the protection of SR_lock. Read from the flag is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  // OK without SR_lock as long as the value is only used as a hint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // (e.g., check _external_suspend first without lock and then recheck
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  // inside SR_lock and finish the suspension)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  // _suspend_flags is also overloaded for other "special conditions" so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // that a single check indicates whether any special action is needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // eg. for async exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // -------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // Notes:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // 1. The suspend/resume logic no longer uses ThreadState in OSThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // but we still update its value to keep other part of the system (mainly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // JVMTI) happy. ThreadState is legacy code (see notes in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // osThread.hpp).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // 2. It would be more natural if set_external_suspend() is private and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // part of java_suspend(), but that probably would affect the suspend/query
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // performance. Need more investigation on this.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // suspend/resume lock: used for self-suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  Monitor*    _SR_lock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  enum SuspendFlags {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    // NOTE: avoid using the sign-bit as cc generates different test code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    //       when the sign-bit is used, and sometimes incorrectly - see CR 6398077
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    _external_suspend       = 0x20000000U, // thread is asked to self suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    _ext_suspended          = 0x40000000U, // thread has self-suspended
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    _has_async_exception    = 0x00000001U  // there is a pending async exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // various suspension related flags - atomically updated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // overloaded for async exception checking in check_special_condition_for_native_trans.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  volatile uint32_t _suspend_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  int _num_nested_signal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  void enter_signal_handler() { _num_nested_signal++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  void leave_signal_handler() { _num_nested_signal--; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  bool is_inside_signal_handler() const  { return _num_nested_signal > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // Debug tracing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  static void trace(const char* msg, const Thread* const thread) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // Active_handles points to a block of handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  JNIHandleBlock* _active_handles;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // One-element thread local free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  JNIHandleBlock* _free_handle_block;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // Point to the last handle mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  HandleMark* _last_handle_mark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // The parity of the last strong_roots iteration in which this thread was
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // claimed as a task.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  jint _oops_do_parity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
   void set_last_handle_mark(HandleMark* mark)   { _last_handle_mark = mark; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    HandleMark* last_handle_mark() const          { return _last_handle_mark; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  // debug support for checking if code does allow safepoints or not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // GC points in the VM can happen because of allocation, invoking a VM operation, or blocking on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // mutex, or blocking on an object synchronizer (Java locking).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // If !allow_safepoint(), then an assertion failure will happen in any of the above cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // If !allow_allocation(), then an assertion failure will happen during allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // (Hence, !allow_safepoint() => !allow_allocation()).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  // The two classes No_Safepoint_Verifier and No_Allocation_Verifier are used to set these counters.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  NOT_PRODUCT(int _allow_safepoint_count;)       // If 0, thread allow a safepoint to happen
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  debug_only (int _allow_allocation_count;)      // If 0, the thread is allowed to allocate oops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
2995
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   194
  // Used by SkipGCALot class.
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   195
  NOT_PRODUCT(bool _skip_gcalot;)                // Should we elide gc-a-lot?
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   196
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Record when GC is locked out via the GC_locker mechanism
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  CHECK_UNHANDLED_OOPS_ONLY(int _gc_locked_out_count;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  friend class No_Alloc_Verifier;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  friend class No_Safepoint_Verifier;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  friend class Pause_No_Safepoint_Verifier;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  friend class ThreadLocalStorage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  friend class GC_locker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  ThreadLocalAllocBuffer _tlab;                  // Thread-local eden
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  int   _vm_operation_started_count;             // VM_Operation support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  int   _vm_operation_completed_count;           // VM_Operation support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  ObjectMonitor* _current_pending_monitor;       // ObjectMonitor this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
                                                 // is waiting to lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  bool _current_pending_monitor_is_from_java;    // locking is from Java code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  // ObjectMonitor on which this thread called Object.wait()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  ObjectMonitor* _current_waiting_monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  // Private thread-local objectmonitor list - a simple cache organized as a SLL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  ObjectMonitor * omFreeList ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  int omFreeCount ;                             // length of omFreeList
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  int omFreeProvision ;                         // reload chunk size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    is_definitely_current_thread = true
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  Thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  virtual ~Thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  // initializtion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  void initialize_thread_local_storage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // thread entry point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // Testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  virtual bool is_VM_thread()       const            { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  virtual bool is_Java_thread()     const            { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  // Remove this ifdef when C1 is ported to the compiler interface.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  virtual bool is_Compiler_thread() const            { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  virtual bool is_hidden_from_external_view() const  { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  virtual bool is_jvmti_agent_thread() const         { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  // True iff the thread can perform GC operations at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // Generally will be true only of VM thread and parallel GC WorkGang
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  // threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  virtual bool is_GC_task_thread() const             { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  virtual bool is_Watcher_thread() const             { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  virtual bool is_ConcurrentGC_thread() const        { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  virtual char* name() const { return (char*)"Unknown thread"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // Returns the current thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  static inline Thread* current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // Common thread operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  static void set_priority(Thread* thread, ThreadPriority priority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  static ThreadPriority get_priority(const Thread* const thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  static void start(Thread* thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  static void interrupt(Thread* thr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  static bool is_interrupted(Thread* thr, bool clear_interrupted);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  Monitor* SR_lock() const                       { return _SR_lock; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  bool has_async_exception() const { return (_suspend_flags & _has_async_exception) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  void set_suspend_flag(SuspendFlags f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    uint32_t flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
      flags = _suspend_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    while (Atomic::cmpxchg((jint)(flags | f),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
                           (volatile jint*)&_suspend_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
                           (jint)flags) != (jint)flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  void clear_suspend_flag(SuspendFlags f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    uint32_t flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
      flags = _suspend_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    while (Atomic::cmpxchg((jint)(flags & ~f),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
                           (volatile jint*)&_suspend_flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
                           (jint)flags) != (jint)flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  void set_has_async_exception() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    set_suspend_flag(_has_async_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  void clear_has_async_exception() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    clear_suspend_flag(_has_async_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Support for Unhandled Oop detection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
#ifdef CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  UnhandledOops *_unhandled_oops;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  UnhandledOops* unhandled_oops()               { return _unhandled_oops; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // Mark oop safe for gc.  It may be stack allocated but won't move.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  void allow_unhandled_oop(oop *op)              {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    if (CheckUnhandledOops) unhandled_oops()->allow_unhandled_oop(op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  // Clear oops at safepoint so crashes point to unhandled oop violator
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  void clear_unhandled_oops()                   {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
    if (CheckUnhandledOops) unhandled_oops()->clear_unhandled_oops();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  bool is_gc_locked_out() { return _gc_locked_out_count > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
#endif // CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
2995
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   314
#ifndef PRODUCT
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   315
  bool skip_gcalot()           { return _skip_gcalot; }
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   316
  void set_skip_gcalot(bool v) { _skip_gcalot = v;    }
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   317
#endif
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 2526
diff changeset
   318
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // Installs a pending exception to be inserted later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  static void send_async_exception(oop thread_oop, oop java_throwable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // Resource area
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  ResourceArea* resource_area() const            { return _resource_area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  void set_resource_area(ResourceArea* area)     { _resource_area = area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  OSThread* osthread() const                     { return _osthread;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  void set_osthread(OSThread* thread)            { _osthread = thread; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // JNI handle support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  JNIHandleBlock* active_handles() const         { return _active_handles; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  void set_active_handles(JNIHandleBlock* block) { _active_handles = block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  JNIHandleBlock* free_handle_block() const      { return _free_handle_block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  void set_free_handle_block(JNIHandleBlock* block) { _free_handle_block = block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // Internal handle support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  HandleArea* handle_area() const                { return _handle_area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  void set_handle_area(HandleArea* area)         { _handle_area = area; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // Thread-Local Allocation Buffer (TLAB) support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  ThreadLocalAllocBuffer& tlab()                 { return _tlab; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  void initialize_tlab() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
    if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
      tlab().initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // VM operation support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  int vm_operation_ticket()                      { return ++_vm_operation_started_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  int vm_operation_completed_count()             { return _vm_operation_completed_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  void increment_vm_operation_completed_count()  { _vm_operation_completed_count++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // For tracking the heavyweight monitor the thread is pending on.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  ObjectMonitor* current_pending_monitor() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    return _current_pending_monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  void set_current_pending_monitor(ObjectMonitor* monitor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    _current_pending_monitor = monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  void set_current_pending_monitor_is_from_java(bool from_java) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    _current_pending_monitor_is_from_java = from_java;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  bool current_pending_monitor_is_from_java() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    return _current_pending_monitor_is_from_java;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // For tracking the ObjectMonitor on which this thread called Object.wait()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  ObjectMonitor* current_waiting_monitor() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    return _current_waiting_monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  void set_current_waiting_monitor(ObjectMonitor* monitor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    _current_waiting_monitor = monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  // GC support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  // Apply "f->do_oop" to all root oops in "this".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  void oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  // Handles the parallel case for the method below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  bool claim_oops_do_par_case(int collection_parity);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // Requires that "collection_parity" is that of the current strong roots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  // iteration.  If "is_par" is false, sets the parity of "this" to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // "collection_parity", and returns "true".  If "is_par" is true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // uses an atomic instruction to set the current threads parity to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  // "collection_parity", if it is not already.  Returns "true" iff the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  // calling thread does the update, this indicates that the calling thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // has claimed the thread's stack as a root groop in the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  bool claim_oops_do(bool is_par, int collection_parity) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    if (!is_par) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
      _oops_do_parity = collection_parity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
      return claim_oops_do_par_case(collection_parity);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  // Sweeper support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  void nmethods_do();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  // Tells if adr belong to this thread. This is used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // for checking if a lock is owned by the running thread.
2526
39a58a50be35 6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents: 2135
diff changeset
   405
39a58a50be35 6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents: 2135
diff changeset
   406
  // Used by fast lock support
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  virtual bool is_lock_owned(address adr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  // 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
   410
  // Warning: the method can only be used on the running thread
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  bool is_in_stack(address adr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  // Sets this thread as starting thread. Returns failure if thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  // creation fails due to lack of memory, too many threads etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  bool set_as_starting_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  // OS data associated with the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  OSThread* _osthread;  // Platform-specific thread information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  // Thread local resource area for temporary allocation within the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  ResourceArea* _resource_area;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  // Thread local handle area for allocation of handles within the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  HandleArea* _handle_area;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  // Support for stack overflow handling, get_thread, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  address          _stack_base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  size_t           _stack_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  uintptr_t        _self_raw_id;      // used by get_thread (mutable)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  int              _lgrp_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  // Stack overflow support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  address stack_base() const           { assert(_stack_base != NULL,"Sanity check"); return _stack_base; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  void    set_stack_base(address base) { _stack_base = base; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  size_t  stack_size() const           { return _stack_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  void    set_stack_size(size_t size)  { _stack_size = size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  void    record_stack_base_and_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  int     lgrp_id() const                 { return _lgrp_id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  void    set_lgrp_id(int value)          { _lgrp_id = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  void print() const { print_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  virtual void print_on_error(outputStream* st, char* buf, int buflen) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // Debug-only code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // Deadlock detection support for Mutex locks. List of locks own by thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  Monitor *_owned_locks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  // Mutex::set_owner_implementation is the only place where _owned_locks is modified,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  // thus the friendship
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  friend class Mutex;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  friend class Monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  void print_owned_locks_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  void print_owned_locks() const                 { print_owned_locks_on(tty);    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  Monitor * owned_locks() const                  { return _owned_locks;          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  bool owns_locks() const                        { return owned_locks() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  bool owns_locks_but_compiled_lock() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  // Deadlock detection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  bool allow_allocation()                        { return _allow_allocation_count == 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  void check_for_valid_safepoint_state(bool potential_vm_operation) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  volatile int _jvmti_env_iteration_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  void entering_jvmti_env_iteration()            { ++_jvmti_env_iteration_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  void leaving_jvmti_env_iteration()             { --_jvmti_env_iteration_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  bool is_inside_jvmti_env_iteration()           { return _jvmti_env_iteration_count > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // Code generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  static ByteSize exception_file_offset()        { return byte_offset_of(Thread, _exception_file   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  static ByteSize exception_line_offset()        { return byte_offset_of(Thread, _exception_line   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  static ByteSize active_handles_offset()        { return byte_offset_of(Thread, _active_handles   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  static ByteSize stack_base_offset()            { return byte_offset_of(Thread, _stack_base ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  static ByteSize stack_size_offset()            { return byte_offset_of(Thread, _stack_size ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  static ByteSize omFreeList_offset()            { return byte_offset_of(Thread, omFreeList); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
#define TLAB_FIELD_OFFSET(name) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  static ByteSize tlab_##name##_offset()            { return byte_offset_of(Thread, _tlab) + ThreadLocalAllocBuffer::name##_offset(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  TLAB_FIELD_OFFSET(start)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  TLAB_FIELD_OFFSET(end)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  TLAB_FIELD_OFFSET(top)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  TLAB_FIELD_OFFSET(pf_top)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  TLAB_FIELD_OFFSET(size)                   // desired_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  TLAB_FIELD_OFFSET(refill_waste_limit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  TLAB_FIELD_OFFSET(number_of_refills)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  TLAB_FIELD_OFFSET(fast_refill_waste)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  TLAB_FIELD_OFFSET(slow_allocations)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
#undef TLAB_FIELD_OFFSET
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  volatile intptr_t _Stalled ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  volatile int _TypeTag ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  ParkEvent * _ParkEvent ;                     // for synchronized()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  ParkEvent * _SleepEvent ;                    // for Thread.sleep
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  ParkEvent * _MutexEvent ;                    // for native internal Mutex/Monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  ParkEvent * _MuxEvent ;                      // for low-level muxAcquire-muxRelease
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  int NativeSyncRecursion ;                    // diagnostic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  volatile int _OnTrap ;                       // Resume-at IP delta
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  jint _hashStateW ;                           // Marsaglia Shift-XOR thread-local RNG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  jint _hashStateX ;                           // thread-specific hashCode generator state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  jint _hashStateY ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  jint _hashStateZ ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  void * _schedctl ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  intptr_t _ScratchA, _ScratchB ;              // Scratch locations for fast-path sync code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  static ByteSize ScratchA_offset()            { return byte_offset_of(Thread, _ScratchA ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  static ByteSize ScratchB_offset()            { return byte_offset_of(Thread, _ScratchB ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  volatile jint rng [4] ;                      // RNG for spin loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  // Low-level leaf-lock primitives used to implement synchronization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // and native monitor-mutex infrastructure.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // Not for general synchronization use.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  static void SpinAcquire (volatile int * Lock, const char * Name) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  static void SpinRelease (volatile int * Lock) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  static void muxAcquire  (volatile intptr_t * Lock, const char * Name) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  static void muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  static void muxRelease  (volatile intptr_t * Lock) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
// Inline implementation of Thread::current()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
// Thread::current is "hot" it's called > 128K times in the 1st 500 msecs of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
// startup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
// ThreadLocalStorage::thread is warm -- it's called > 16K times in the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
// period.   This is inlined in thread_<os_family>.inline.hpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
inline Thread* Thread::current() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
// This function is very high traffic. Define PARANOID to enable expensive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
// asserts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
#ifdef PARANOID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  // Signal handler should call ThreadLocalStorage::get_thread_slow()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  Thread* t = ThreadLocalStorage::get_thread_slow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  assert(t != NULL && !t->is_inside_signal_handler(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
         "Don't use Thread::current() inside signal handler");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  Thread* thread = ThreadLocalStorage::thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  assert(thread != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  return thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// Name support for threads.  non-JavaThread subclasses with multiple
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// uniquely named instances should derive from this.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
class NamedThread: public Thread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    max_name_len = 64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  char* _name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  NamedThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  ~NamedThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  // May only be called once per thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  void set_name(const char* format, ...);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  virtual char* name() const { return _name == NULL ? (char*)"Unknown Thread" : _name; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
// Worker threads are named and have an id of an assigned work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
class WorkerThread: public NamedThread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  uint _id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  WorkerThread() : _id(0) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  void set_id(uint work_id) { _id = work_id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  uint id() const { return _id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
// A single WatcherThread is used for simulating timer interrupts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
class WatcherThread: public Thread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  static WatcherThread* _watcher_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  static bool _should_terminate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  enum SomeConstants {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
    delay_interval = 10                          // interrupt delay in milliseconds
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  WatcherThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  // Tester
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  bool is_Watcher_thread() const                 { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  char* name() const { return (char*)"VM Periodic Task Thread"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  void print() const { print_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  // Returns the single instance of WatcherThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  static WatcherThread* watcher_thread()         { return _watcher_thread; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  // Create and start the single instance of WatcherThread, or stop it on shutdown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  static void start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  static void stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
class CompilerThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
typedef void (*ThreadFunction)(JavaThread*, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
class JavaThread: public Thread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  JavaThread*    _next;                          // The next thread in the Threads list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  oop            _threadObj;                     // The Java level thread object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  int _java_call_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  int  java_call_counter()                       { return _java_call_counter; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  void inc_java_call_counter()                   { _java_call_counter++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  void dec_java_call_counter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    assert(_java_call_counter > 0, "Invalid nesting of JavaCallWrapper");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
    _java_call_counter--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
 private:  // restore original namespace restriction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
#endif  // ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    jump_ring_buffer_size = 16
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
 private:  // restore original namespace restriction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  JavaFrameAnchor _anchor;                       // Encapsulation of current java frame and it state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  ThreadFunction _entry_point;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  JNIEnv        _jni_environment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  // Deopt support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  DeoptResourceMark*  _deopt_mark;               // Holds special ResourceMark for deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  intptr_t*      _must_deopt_id;                 // id of frame that needs to be deopted once we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
                                                 // transition out of native
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  vframeArray*  _vframe_array_head;              // Holds the heap of the active vframeArrays
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  vframeArray*  _vframe_array_last;              // Holds last vFrameArray we popped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  // Because deoptimization is lazy we must save jvmti requests to set locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  // in compiled frames until we deoptimize and we have an interpreter frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  // This holds the pointer to array (yeah like there might be more than one) of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  // description of compiled vframes that have locals that need to be updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  GrowableArray<jvmtiDeferredLocalVariableSet*>* _deferred_locals_updates;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  // Handshake value for fixing 6243940. We need a place for the i2c
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  // adapter to store the callee methodOop. This value is NEVER live
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  // across a gc point so it does NOT have to be gc'd
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  // The handshake is open ended since we can't be certain that it will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  // be NULLed. This is because we rarely ever see the race and end up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  // in handle_wrong_method which is the backend of the handshake. See
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  // code in i2c adapters and handle_wrong_method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  methodOop     _callee_target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // Oop results of VM runtime calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  oop           _vm_result;                      // Used to pass back an oop result into Java code, GC-preserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  oop           _vm_result_2;                    // Used to pass back an oop result into Java code, GC-preserved
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  MonitorChunk* _monitor_chunks;                 // Contains the off stack monitors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
                                                 // allocated during deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
                                                 // and by JNI_MonitorEnter/Exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  // Async. requests support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  enum AsyncRequests {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    _no_async_condition = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
    _async_exception,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
    _async_unsafe_access_error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  AsyncRequests _special_runtime_exit_condition; // Enum indicating pending async. request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  oop           _pending_async_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  // Safepoint support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
 public:                                         // Expose _thread_state for SafeFetchInt()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  volatile JavaThreadState _thread_state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  ThreadSafepointState *_safepoint_state;        // Holds information about a thread during a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  address               _saved_exception_pc;     // Saved pc of instruction where last implicit exception happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  // JavaThread termination support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  enum TerminatedTypes {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    _not_terminated = 0xDEAD - 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    _thread_exiting,                             // JavaThread::exit() has been called for this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
    _thread_terminated,                          // JavaThread is removed from thread list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    _vm_exited                                   // JavaThread is still executing native code, but VM is terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
                                                 // only VM_Exit can set _vm_exited
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  // In general a JavaThread's _terminated field transitions as follows:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  //   _not_terminated => _thread_exiting => _thread_terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  // _vm_exited is a special value to cover the case of a JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  // executing native code after the VM itself is terminated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  TerminatedTypes       _terminated;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  // suspend/resume support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  volatile bool         _suspend_equivalent;     // Suspend equivalent condition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  jint                  _in_deopt_handler;       // count of deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
                                                 // handlers thread is in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  volatile bool         _doing_unsafe_access;    // Thread may fault due to unsafe access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  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
   731
                                                 // never locked) when throwing an exception. Used by interpreter only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  //  Flag to mark a JNI thread in the process of attaching - See CR 6404306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  //  This flag is never set true other than at construction, and in that case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  //  is shortly thereafter set false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  volatile bool _is_attaching;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  // State of the stack guard pages for this thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  enum StackGuardState {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    stack_guard_unused,         // not needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
    stack_guard_yellow_disabled,// disabled (temporarily) after stack overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
    stack_guard_enabled         // enabled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  StackGuardState        _stack_guard_state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // Compiler exception handling (NOTE: The _exception_oop is *NOT* the same as _pending_exception. It is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  // used to temp. parsing values into and out of the runtime system during exception handling for compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  // code)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  volatile oop     _exception_oop;               // Exception thrown in compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  volatile address _exception_pc;                // PC where exception happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  volatile address _exception_handler_pc;        // PC for handler of exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  volatile int     _exception_stack_size;        // Size of frame where exception happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  // support for compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  bool    _is_compiling;                         // is true if a compilation is active inthis thread (one compilation per thread possible)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  // support for JNI critical regions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  jint    _jni_active_critical;                  // count of entries into JNI critical region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  // For deadlock detection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  int _depth_first_number;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  // JVMTI PopFrame support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  // This is set to popframe_pending to signal that top Java frame should be popped immediately
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  int _popframe_condition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  int _jmp_ring_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
      // We use intptr_t instead of address so debugger doesn't try and display strings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
      intptr_t _target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
      intptr_t _instruction;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
      const char*  _file;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
      int _line;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  }   _jmp_ring[ jump_ring_buffer_size ];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   782
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   783
  // Support for G1 barriers
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   784
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   785
  ObjPtrQueue _satb_mark_queue;          // Thread-local log for SATB barrier.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   786
  // Set of all such queues.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   787
  static SATBMarkQueueSet _satb_mark_queue_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   788
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   789
  DirtyCardQueue _dirty_card_queue;      // Thread-local log for dirty cards.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   790
  // Set of all such queues.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   791
  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
   792
1b328492b7f8 6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents: 1374
diff changeset
   793
  void flush_barrier_queues();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   794
#endif // !SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   795
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  friend class VMThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  friend class ThreadWaitTransition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  friend class VM_Exit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  void initialize();                             // Initialized the instance variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  JavaThread(bool is_attaching = false); // for main thread and JNI attached threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  JavaThread(ThreadFunction entry_point, size_t stack_size = 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  ~JavaThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  // verify this JavaThread hasn't be published in the Threads::list yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  void verify_not_published();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  //JNI functiontable getter/setter for JVMTI jni function table interception API.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  void set_jni_functions(struct JNINativeInterface_* functionTable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
    _jni_environment.functions = functionTable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  struct JNINativeInterface_* get_jni_functions() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
    return (struct JNINativeInterface_ *)_jni_environment.functions;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  // Executes Shutdown.shutdown()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  void invoke_shutdown_hooks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  // Cleanup on thread exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  enum ExitType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    normal_exit,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
    jni_detach
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  void exit(bool destroy_vm, ExitType exit_type = normal_exit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  void cleanup_failed_attach_current_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  // Testers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  virtual bool is_Java_thread() const            { return true;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  // compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  void set_is_compiling(bool f)                  { _is_compiling = f; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  bool is_compiling() const                      { return _is_compiling; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  // Thread chain operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  JavaThread* next() const                       { return _next; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  void set_next(JavaThread* p)                   { _next = p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  // Thread oop. threadObj() can be NULL for initial JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  // (or for threads attached via JNI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  oop threadObj() const                          { return _threadObj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  void set_threadObj(oop p)                      { _threadObj = p; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  ThreadPriority java_priority() const;          // Read from threadObj()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  // Prepare thread and add to priority queue.  If a priority is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  // not specified, use the priority of the thread object. Threads_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  // must be held while this function is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  void prepare(jobject jni_thread, ThreadPriority prio=NoPriority);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  void set_saved_exception_pc(address pc)        { _saved_exception_pc = pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  address saved_exception_pc()                   { return _saved_exception_pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  ThreadFunction entry_point() const             { return _entry_point; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  // Allocates a new Java level thread object for this thread. thread_name may be NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  void allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  // Last frame anchor routines
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  JavaFrameAnchor* frame_anchor(void)                { return &_anchor; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  // last_Java_sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  bool has_last_Java_frame() const                   { return _anchor.has_last_Java_frame(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  intptr_t* last_Java_sp() const                     { return _anchor.last_Java_sp(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  // last_Java_pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  address last_Java_pc(void)                         { return _anchor.last_Java_pc(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  // Safepoint support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  JavaThreadState thread_state() const           { return _thread_state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  void set_thread_state(JavaThreadState s)       { _thread_state=s;      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  ThreadSafepointState *safepoint_state() const  { return _safepoint_state;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  void set_safepoint_state(ThreadSafepointState *state) { _safepoint_state = state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  bool is_at_poll_safepoint()                    { return _safepoint_state->is_at_poll_safepoint(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  // thread has called JavaThread::exit() or is terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  bool is_exiting()                              { return _terminated == _thread_exiting || is_terminated(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  // thread is terminated (no longer on the threads list); we compare
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  // against the two non-terminated values so that a freed JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  // will also be considered terminated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  bool is_terminated()                           { return _terminated != _not_terminated && _terminated != _thread_exiting; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  void set_terminated(TerminatedTypes t)         { _terminated = t; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  // special for Threads::remove() which is static:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  void set_terminated_value()                    { _terminated = _thread_terminated; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  void block_if_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  bool doing_unsafe_access()                     { return _doing_unsafe_access; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  void set_doing_unsafe_access(bool val)         { _doing_unsafe_access = val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  bool do_not_unlock_if_synchronized()             { return _do_not_unlock_if_synchronized; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  void set_do_not_unlock_if_synchronized(bool val) { _do_not_unlock_if_synchronized = val; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  // Suspend/resume support for JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  void set_ext_suspended()       { set_suspend_flag (_ext_suspended);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  void clear_ext_suspended()     { clear_suspend_flag(_ext_suspended); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  void java_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  void java_resume();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  int  java_suspend_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  void check_and_wait_while_suspended() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
    assert(JavaThread::current() == this, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
    bool do_self_suspend;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
      // were we externally suspended while we were waiting?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
      do_self_suspend = handle_special_suspend_equivalent_condition();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
      if (do_self_suspend) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
        // don't surprise the thread that suspended us by returning
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
        java_suspend_self();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
        set_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
    } while (do_self_suspend);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  static void check_safepoint_and_suspend_for_native_trans(JavaThread *thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  // Check for async exception in addition to safepoint and suspend request.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  static void check_special_condition_for_native_trans(JavaThread *thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  bool is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  bool is_ext_suspend_completed_with_lock(uint32_t *bits) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    // Warning: is_ext_suspend_completed() may temporarily drop the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
    // SR_lock to allow the thread to reach a stable thread state if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
    // it is currently in a transient thread state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
    return is_ext_suspend_completed(false /*!called_by_wait */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
                                    SuspendRetryDelay, bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  // We cannot allow wait_for_ext_suspend_completion() to run forever or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  // we could hang. SuspendRetryCount and SuspendRetryDelay are normally
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  // passed as the count and delay parameters. Experiments with specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  // calls to wait_for_ext_suspend_completion() can be done by passing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  // other values in the code. Experiments with all calls can be done
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  // via the appropriate -XX options.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  bool wait_for_ext_suspend_completion(int count, int delay, uint32_t *bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  void set_external_suspend()     { set_suspend_flag  (_external_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  void clear_external_suspend()   { clear_suspend_flag(_external_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  void set_deopt_suspend()        { set_suspend_flag  (_deopt_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  void clear_deopt_suspend()      { clear_suspend_flag(_deopt_suspend); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  bool is_deopt_suspend()         { return (_suspend_flags & _deopt_suspend) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  bool is_external_suspend() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    return (_suspend_flags & _external_suspend) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  // Whenever a thread transitions from native to vm/java it must suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  // if external|deopt suspend is present.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  bool is_suspend_after_native() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    return (_suspend_flags & (_external_suspend | _deopt_suspend) ) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  // external suspend request is completed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  bool is_ext_suspended() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
    return (_suspend_flags & _ext_suspended) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  bool is_external_suspend_with_lock() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
    return is_external_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  // Special method to handle a pending external suspend request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  // when a suspend equivalent condition lifts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  bool handle_special_suspend_equivalent_condition() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
    assert(is_suspend_equivalent(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
      "should only be called in a suspend equivalence condition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
    bool ret = is_external_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
    if (!ret) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
      // not about to self-suspend so clear suspend equivalence
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
      clear_suspend_equivalent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
    // implied else:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    // We have a pending external suspend request so we leave the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
    // suspend_equivalent flag set until java_suspend_self() sets
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
    // the ext_suspended flag and clears the suspend_equivalent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
    // flag. This insures that wait_for_ext_suspend_completion()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    // will return consistent values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  // utility methods to see if we are doing some kind of suspension
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  bool is_being_ext_suspended() const            {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
    MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
    return is_ext_suspended() || is_external_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  bool is_suspend_equivalent() const             { return _suspend_equivalent; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  void set_suspend_equivalent()                  { _suspend_equivalent = true; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  void clear_suspend_equivalent()                { _suspend_equivalent = false; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  // Thread.stop support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  void send_thread_stop(oop throwable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  AsyncRequests clear_special_runtime_exit_condition() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
    AsyncRequests x = _special_runtime_exit_condition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    _special_runtime_exit_condition = _no_async_condition;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
    return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  // Are any async conditions present?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  bool has_async_condition() { return (_special_runtime_exit_condition != _no_async_condition); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  void check_and_handle_async_exceptions(bool check_unsafe_error = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  // these next two are also used for self-suspension and async exception support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  void handle_special_runtime_exit_condition(bool check_asyncs = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  // Return true if JavaThread has an asynchronous condition or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  // if external suspension is requested.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  bool has_special_runtime_exit_condition() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
    // We call is_external_suspend() last since external suspend should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
    // be less common. Because we don't use is_external_suspend_with_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
    // it is possible that we won't see an asynchronous external suspend
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
    // request that has just gotten started, i.e., SR_lock grabbed but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
    // _external_suspend field change either not made yet or not visible
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
    // yet. However, this is okay because the request is asynchronous and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
    // we will see the new flag value the next time through. It's also
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
    // possible that the external suspend request is dropped after
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
    // we have checked is_external_suspend(), we will recheck its value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
    // under SR_lock in java_suspend_self().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
    return (_special_runtime_exit_condition != _no_async_condition) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
            is_external_suspend() || is_deopt_suspend();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  void set_pending_unsafe_access_error()          { _special_runtime_exit_condition = _async_unsafe_access_error; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  void set_pending_async_exception(oop e) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
    _pending_async_exception = e;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
    _special_runtime_exit_condition = _async_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
    set_has_async_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  // Fast-locking support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  bool is_lock_owned(address adr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
  // Accessors for vframe array top
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
  // The linked list of vframe arrays are sorted on sp. This means when we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
  // unpack the head must contain the vframe array to unpack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  void set_vframe_array_head(vframeArray* value) { _vframe_array_head = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  vframeArray* vframe_array_head() const         { return _vframe_array_head;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  // Side structure for defering update of java frame locals until deopt occurs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred_locals() const { return _deferred_locals_updates; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  void set_deferred_locals(GrowableArray<jvmtiDeferredLocalVariableSet *>* vf) { _deferred_locals_updates = vf; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  // These only really exist to make debugging deopt problems simpler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
  void set_vframe_array_last(vframeArray* value) { _vframe_array_last = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  vframeArray* vframe_array_last() const         { return _vframe_array_last;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  // The special resourceMark used during deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  void set_deopt_mark(DeoptResourceMark* value)  { _deopt_mark = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  DeoptResourceMark* deopt_mark(void)            { return _deopt_mark; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  intptr_t* must_deopt_id()                      { return _must_deopt_id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  void     set_must_deopt_id(intptr_t* id)       { _must_deopt_id = id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
  void     clear_must_deopt_id()                 { _must_deopt_id = NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
  methodOop  callee_target() const               { return _callee_target; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  void set_callee_target  (methodOop x)          { _callee_target   = x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  // Oop results of vm runtime calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  oop  vm_result() const                         { return _vm_result; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  void set_vm_result  (oop x)                    { _vm_result   = x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
  oop  vm_result_2() const                       { return _vm_result_2; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  void set_vm_result_2  (oop x)                  { _vm_result_2   = x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  // Exception handling for compiled methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  oop      exception_oop() const                 { return _exception_oop; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  int      exception_stack_size() const          { return _exception_stack_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  address  exception_pc() const                  { return _exception_pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  address  exception_handler_pc() const          { return _exception_handler_pc; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  void set_exception_oop(oop o)                  { _exception_oop = o; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  void set_exception_pc(address a)               { _exception_pc = a; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  void set_exception_handler_pc(address a)       { _exception_handler_pc = a; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  void set_exception_stack_size(int size)        { _exception_stack_size = size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  // Stack overflow support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  inline size_t stack_available(address cur_sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  address stack_yellow_zone_base()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
    { return (address)(stack_base() - (stack_size() - (stack_red_zone_size() + stack_yellow_zone_size()))); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  size_t  stack_yellow_zone_size()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
    { return StackYellowPages * os::vm_page_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  address stack_red_zone_base()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
    { return (address)(stack_base() - (stack_size() - stack_red_zone_size())); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
  size_t stack_red_zone_size()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
    { return StackRedPages * os::vm_page_size(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  bool in_stack_yellow_zone(address a)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    { return (a <= stack_yellow_zone_base()) && (a >= stack_red_zone_base()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  bool in_stack_red_zone(address a)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
    { return (a <= stack_red_zone_base()) && (a >= (address)((intptr_t)stack_base() - stack_size())); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  void create_stack_guard_pages();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
  void remove_stack_guard_pages();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  void enable_stack_yellow_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  void disable_stack_yellow_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  void enable_stack_red_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  void disable_stack_red_zone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  inline bool stack_yellow_zone_disabled();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  inline bool stack_yellow_zone_enabled();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  // Attempt to reguard the stack after a stack overflow may have occurred.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  // Returns true if (a) guard pages are not needed on this thread, (b) the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  // pages are already guarded, or (c) the pages were successfully reguarded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  // Returns false if there is not enough stack space to reguard the pages, in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  // which case the caller should unwind a frame and try again.  The argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  // should be the caller's (approximate) sp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  bool reguard_stack(address cur_sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  // Similar to above but see if current stackpoint is out of the guard area
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  // and reguard if possible.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  bool reguard_stack(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  // Misc. accessors/mutators
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  void set_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  void clr_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  bool do_not_unlock(void)                       { return _do_not_unlock_if_synchronized; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  void record_jump(address target, address instr, const char* file, int line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  // For assembly stub generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  static ByteSize threadObj_offset()             { return byte_offset_of(JavaThread, _threadObj           ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  static ByteSize jmp_ring_index_offset()        { return byte_offset_of(JavaThread, _jmp_ring_index      ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  static ByteSize jmp_ring_offset()              { return byte_offset_of(JavaThread, _jmp_ring            ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  static ByteSize jni_environment_offset()       { return byte_offset_of(JavaThread, _jni_environment     ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  static ByteSize last_Java_sp_offset()          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_sp_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  static ByteSize last_Java_pc_offset()          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_pc_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  static ByteSize frame_anchor_offset()          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    return byte_offset_of(JavaThread, _anchor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  static ByteSize callee_target_offset()         { return byte_offset_of(JavaThread, _callee_target       ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
  static ByteSize vm_result_offset()             { return byte_offset_of(JavaThread, _vm_result           ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  static ByteSize vm_result_2_offset()           { return byte_offset_of(JavaThread, _vm_result_2         ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
  static ByteSize thread_state_offset()          { return byte_offset_of(JavaThread, _thread_state        ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  static ByteSize saved_exception_pc_offset()    { return byte_offset_of(JavaThread, _saved_exception_pc  ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
  static ByteSize osthread_offset()              { return byte_offset_of(JavaThread, _osthread            ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
  static ByteSize exception_oop_offset()         { return byte_offset_of(JavaThread, _exception_oop       ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
  static ByteSize exception_pc_offset()          { return byte_offset_of(JavaThread, _exception_pc        ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  static ByteSize exception_handler_pc_offset()  { return byte_offset_of(JavaThread, _exception_handler_pc); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
  static ByteSize exception_stack_size_offset()  { return byte_offset_of(JavaThread, _exception_stack_size); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
  static ByteSize stack_guard_state_offset()     { return byte_offset_of(JavaThread, _stack_guard_state   ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  static ByteSize suspend_flags_offset()         { return byte_offset_of(JavaThread, _suspend_flags       ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  static ByteSize do_not_unlock_if_synchronized_offset() { return byte_offset_of(JavaThread, _do_not_unlock_if_synchronized); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1172
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1173
  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
  1174
  static ByteSize dirty_card_queue_offset()      { return byte_offset_of(JavaThread, _dirty_card_queue); }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1175
#endif // !SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1176
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  // Returns the jni environment for this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  JNIEnv* jni_environment()                      { return &_jni_environment; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  static JavaThread* thread_from_jni_environment(JNIEnv* env) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
    JavaThread *thread_from_jni_env = (JavaThread*)((intptr_t)env - in_bytes(jni_environment_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
    // Only return NULL if thread is off the thread list; starting to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
    // exit should not return NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
    if (thread_from_jni_env->is_terminated()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
       thread_from_jni_env->block_if_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
       return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
       return thread_from_jni_env;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  // JNI critical regions. These can nest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  bool in_critical()    { return _jni_active_critical > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
  void enter_critical() { assert(Thread::current() == this,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
                                 "this must be current thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
                          _jni_active_critical++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  void exit_critical()  { assert(Thread::current() == this,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
                                 "this must be current thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
                          _jni_active_critical--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
                          assert(_jni_active_critical >= 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
                                 "JNI critical nesting problem?"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
  // For deadlock detection
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  int depth_first_number() { return _depth_first_number; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  void set_depth_first_number(int dfn) { _depth_first_number = dfn; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  void set_monitor_chunks(MonitorChunk* monitor_chunks) { _monitor_chunks = monitor_chunks; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
  MonitorChunk* monitor_chunks() const           { return _monitor_chunks; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
  void add_monitor_chunk(MonitorChunk* chunk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  void remove_monitor_chunk(MonitorChunk* chunk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
  bool in_deopt_handler() const                  { return _in_deopt_handler > 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  void inc_in_deopt_handler()                    { _in_deopt_handler++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  void dec_in_deopt_handler()                    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
    assert(_in_deopt_handler > 0, "mismatched deopt nesting");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    if (_in_deopt_handler > 0) { // robustness
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
      _in_deopt_handler--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
  void set_entry_point(ThreadFunction entry_point) { _entry_point = entry_point; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  // Frame iteration; calls the function f for all frames on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  void frames_do(void f(frame*, const RegisterMap*));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  // Memory operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
  void oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  // Sweeper operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  void nmethods_do();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  // Memory management operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  void gc_epilogue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  void gc_prologue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  // Misc. operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
  char* name() const { return (char*)get_thread_name(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
  void print() const { print_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  void print_value();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
  void print_thread_state_on(outputStream* ) const      PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  void print_thread_state() const                       PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
  void print_on_error(outputStream* st, char* buf, int buflen) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
  void verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
  const char* get_thread_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  // factor out low-level mechanics for use in both normal and error cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  const char* get_thread_name_string(char* buf = NULL, int buflen = 0) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
  const char* get_threadgroup_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  const char* get_parent_name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  // Accessing frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  frame last_frame() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
    _anchor.make_walkable(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
    return pd_last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  javaVFrame* last_java_vframe(RegisterMap* reg_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  // Returns method at 'depth' java or native frames down the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
  // Used for security checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
  klassOop security_get_caller_class(int depth);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
  // Print stack trace in external format
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  void print_stack_on(outputStream* st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  void print_stack() { print_stack_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  // Print stack traces in various internal formats
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  void trace_stack()                             PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  void trace_stack_from(vframe* start_vf)        PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  void trace_frames()                            PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  // Returns the number of stack frames on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  int depth() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
  // Function for testing deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  void deoptimize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  void make_zombies();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  void deoptimized_wrt_marked_nmethods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  // Profiling operation (see fprofile.cpp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
   bool profile_last_Java_frame(frame* fr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
   ThreadProfiler* _thread_profiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
   friend class FlatProfiler;                    // uses both [gs]et_thread_profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
   friend class FlatProfilerTask;                // uses get_thread_profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
   friend class ThreadProfilerMark;              // uses get_thread_profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
   ThreadProfiler* get_thread_profiler()         { return _thread_profiler; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
   ThreadProfiler* set_thread_profiler(ThreadProfiler* tp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
     ThreadProfiler* result = _thread_profiler;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
     _thread_profiler = tp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
     return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  // Static operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
  // Returns the running thread as a JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  static inline JavaThread* current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
  // Returns the active Java thread.  Do not use this if you know you are calling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
  // from a JavaThread, as it's slower than JavaThread::current.  If called from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  // the VMThread, it also returns the JavaThread that instigated the VMThread's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  // operation.  You may not want that either.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
  static JavaThread* active();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  inline CompilerThread* as_CompilerThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  void thread_main_inner();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
  // PRIVILEGED STACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  PrivilegedElement*  _privileged_stack_top;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  GrowableArray<oop>* _array_for_gc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  // Returns the privileged_stack information.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  PrivilegedElement* privileged_stack_top() const       { return _privileged_stack_top; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  void set_privileged_stack_top(PrivilegedElement *e)   { _privileged_stack_top = e; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
  void register_array_for_gc(GrowableArray<oop>* array) { _array_for_gc = array; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  // Thread local information maintained by JVMTI.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  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
  1335
  // 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
  1336
  // 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
  1337
  // 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
  1338
  // 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
  1339
  // 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
  1340
  // 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
  1341
  // the specified JavaThread is exiting.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  JvmtiThreadState *jvmti_thread_state() const                                   { return _jvmti_thread_state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  static ByteSize jvmti_thread_state_offset()                                    { return byte_offset_of(JavaThread, _jvmti_thread_state); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
  void set_jvmti_get_loaded_classes_closure(JvmtiGetLoadedClassesClosure* value) { _jvmti_get_loaded_classes_closure = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
  JvmtiGetLoadedClassesClosure* get_jvmti_get_loaded_classes_closure() const     { return _jvmti_get_loaded_classes_closure; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  // JVMTI PopFrame support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
  // Setting and clearing popframe_condition
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
  // All of these enumerated values are bits. popframe_pending
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  // indicates that a PopFrame() has been requested and not yet been
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
  // completed. popframe_processing indicates that that PopFrame() is in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
  // the process of being completed. popframe_force_deopt_reexecution_bit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  // indicates that special handling is required when returning to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  // deoptimized caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  enum PopCondition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
    popframe_inactive                      = 0x00,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
    popframe_pending_bit                   = 0x01,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    popframe_processing_bit                = 0x02,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
    popframe_force_deopt_reexecution_bit   = 0x04
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  PopCondition popframe_condition()                   { return (PopCondition) _popframe_condition; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
  void set_popframe_condition(PopCondition c)         { _popframe_condition = c; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  void set_popframe_condition_bit(PopCondition c)     { _popframe_condition |= c; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  void clear_popframe_condition()                     { _popframe_condition = popframe_inactive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
  static ByteSize popframe_condition_offset()         { return byte_offset_of(JavaThread, _popframe_condition); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  bool has_pending_popframe()                         { return (popframe_condition() & popframe_pending_bit) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  bool popframe_forcing_deopt_reexecution()           { return (popframe_condition() & popframe_force_deopt_reexecution_bit) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  void clear_popframe_forcing_deopt_reexecution()     { _popframe_condition &= ~popframe_force_deopt_reexecution_bit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  bool pop_frame_pending(void)                        { return ((_popframe_condition & popframe_pending_bit) != 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  void clr_pop_frame_pending(void)                    { _popframe_condition = popframe_inactive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  bool pop_frame_in_process(void)                     { return ((_popframe_condition & popframe_processing_bit) != 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  void set_pop_frame_in_process(void)                 { _popframe_condition |= popframe_processing_bit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  void clr_pop_frame_in_process(void)                 { _popframe_condition &= ~popframe_processing_bit; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
  // Saved incoming arguments to popped frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
  // Used only when popped interpreted frame returns to deoptimized frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
  void*    _popframe_preserved_args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  int      _popframe_preserved_args_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  void  popframe_preserve_args(ByteSize size_in_bytes, void* start);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
  void* popframe_preserved_args();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  ByteSize popframe_preserved_args_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
  WordSize popframe_preserved_args_size_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  void  popframe_free_preserved_args();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
  JvmtiThreadState *_jvmti_thread_state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
  JvmtiGetLoadedClassesClosure* _jvmti_get_loaded_classes_closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
  // Used by the interpreter in fullspeed mode for frame pop, method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
  // entry, method exit and single stepping support. This field is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  // only set to non-zero by the VM_EnterInterpOnlyMode VM operation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
  // It can be set to zero asynchronously (i.e., without a VM operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
  // or a lock) so we have to be very careful.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  int               _interp_only_mode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
  // used by the interpreter for fullspeed debugging support (see above)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
  static ByteSize interp_only_mode_offset() { return byte_offset_of(JavaThread, _interp_only_mode); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
  bool is_interp_only_mode()                { return (_interp_only_mode != 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  int get_interp_only_mode()                { return _interp_only_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  void increment_interp_only_mode()         { ++_interp_only_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  void decrement_interp_only_mode()         { --_interp_only_mode; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
  ThreadStatistics *_thread_stat;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
  ThreadStatistics* get_thread_stat() const    { return _thread_stat; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  // Return a blocker object for which this thread is blocked parking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  oop current_park_blocker();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  static size_t _stack_size_at_create;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
  static inline size_t stack_size_at_create(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
    return _stack_size_at_create;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
  static inline void set_stack_size_at_create(size_t value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
    _stack_size_at_create = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1430
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1431
  // SATB marking queue support
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1432
  ObjPtrQueue& satb_mark_queue() { return _satb_mark_queue; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1433
  static SATBMarkQueueSet& satb_mark_queue_set() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1434
    return _satb_mark_queue_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1435
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1436
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1437
  // Dirty card queue support
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1438
  DirtyCardQueue& dirty_card_queue() { return _dirty_card_queue; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1439
  static DirtyCardQueueSet& dirty_card_queue_set() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1440
    return _dirty_card_queue_set;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1441
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1442
#endif // !SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1443
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
  // Machine dependent stuff
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
  #include "incls/_thread_pd.hpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
  void set_blocked_on_compilation(bool value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
    _blocked_on_compilation = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
  bool blocked_on_compilation() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
    return _blocked_on_compilation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
  bool         _blocked_on_compilation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
  // JSR166 per-thread parker
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
  Parker*    _parker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
  Parker*     parker() { return _parker; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
  // Biased locking support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
  GrowableArray<MonitorInfo*>* _cached_monitor_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
  GrowableArray<MonitorInfo*>* cached_monitor_info() { return _cached_monitor_info; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
  void set_cached_monitor_info(GrowableArray<MonitorInfo*>* info) { _cached_monitor_info = info; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
  // clearing/querying jni attach status
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
  bool is_attaching() const { return _is_attaching; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
  void set_attached() { _is_attaching = false; OrderAccess::fence(); }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1475
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1476
  // 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
  1477
  // 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
  1478
  // 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
  1479
  int _claimed_par_id;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1480
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1481
  int get_claimed_par_id() { return _claimed_par_id; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
  1482
  void set_claimed_par_id(int id) { _claimed_par_id = id;}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
// Inline implementation of JavaThread::current
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
inline JavaThread* JavaThread::current() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
  Thread* thread = ThreadLocalStorage::thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  assert(thread != NULL && thread->is_Java_thread(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
  return (JavaThread*)thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
inline CompilerThread* JavaThread::as_CompilerThread() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  assert(is_Compiler_thread(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
  return (CompilerThread*)this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
inline bool JavaThread::stack_yellow_zone_disabled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
  return _stack_guard_state == stack_guard_yellow_disabled;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
inline bool JavaThread::stack_yellow_zone_enabled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
  if (os::uses_stack_guard_pages()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
    assert(_stack_guard_state != stack_guard_unused, "guard pages must be in use");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
    return _stack_guard_state == stack_guard_enabled;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
inline size_t JavaThread::stack_available(address cur_sp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  // This code assumes java stacks grow down
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  address low_addr; // Limit on the address for deepest stack depth
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
  if ( _stack_guard_state == stack_guard_unused) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
    low_addr =  stack_base() - stack_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
    low_addr = stack_yellow_zone_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  return cur_sp > low_addr ? cur_sp - low_addr : 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
// A JavaThread for low memory detection support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
class LowMemoryDetectorThread : public JavaThread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  LowMemoryDetectorThread(ThreadFunction entry_point) : JavaThread(entry_point) {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
  // Hide this thread from external view.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
  bool is_hidden_from_external_view() const      { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
// A thread used for Compilation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
class CompilerThread : public JavaThread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
  CompilerCounters* _counters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
  ciEnv*        _env;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
  CompileLog*   _log;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
  CompileTask*  _task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
  CompileQueue* _queue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
  static CompilerThread* current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
  CompilerThread(CompileQueue* queue, CompilerCounters* counters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
  bool is_Compiler_thread() const                { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
  // Hide this compiler thread from external view.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
  bool is_hidden_from_external_view() const      { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
  CompileQueue* queue()                          { return _queue; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
  CompilerCounters* counters()                   { return _counters; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
  // Get/set the thread's compilation environment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
  ciEnv*        env()                            { return _env; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
  void          set_env(ciEnv* env)              { _env = env; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
  // Get/set the thread's logging information
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
  CompileLog*   log()                            { return _log; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
  void          init_log(CompileLog* log) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
    // Set once, for good.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
    assert(_log == NULL, "set only once");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
    _log = log;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
  IdealGraphPrinter *_ideal_graph_printer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  IdealGraphPrinter *ideal_graph_printer()                       { return _ideal_graph_printer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
  void set_ideal_graph_printer(IdealGraphPrinter *n)             { _ideal_graph_printer = n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
  // Get/set the thread's current task
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
  CompileTask*  task()                           { return _task; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
  void          set_task(CompileTask* task)      { _task = task; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
inline CompilerThread* CompilerThread::current() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
  return JavaThread::current()->as_CompilerThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
// The active thread queue. It also keeps track of the current used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
// thread priorities.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
class Threads: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  static JavaThread* _thread_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  static int         _number_of_threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
  static int         _number_of_non_daemon_threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
  static int         _return_code;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  // Thread management
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
  // force_daemon is a concession to JNI, where we may need to add a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
  // thread to the thread list before allocating its thread object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
  static void add(JavaThread* p, bool force_daemon = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
  static void remove(JavaThread* p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
  static bool includes(JavaThread* p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
  static JavaThread* first()                     { return _thread_list; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
  static void threads_do(ThreadClosure* tc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
  // Initializes the vm and creates the vm thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
  static jint create_vm(JavaVMInitArgs* args, bool* canTryAgain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
  static void convert_vm_init_libraries_to_agents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
  static void create_vm_init_libraries();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
  static void create_vm_init_agents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
  static void shutdown_vm_agents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
  static bool destroy_vm();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
  // Supported VM versions via JNI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
  // Includes JNI_VERSION_1_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  static jboolean is_supported_jni_version_including_1_1(jint version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
  // Does not include JNI_VERSION_1_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
  static jboolean is_supported_jni_version(jint version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  // Garbage collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  static void follow_other_roots(void f(oop*));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  // Apply "f->do_oop" to all root oops in all threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
  // This version may only be called by sequential code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  static void oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
  // This version may be called by sequential or parallel code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
  static void possibly_parallel_oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  // This creates a list of GCTasks, one per thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  static void create_thread_roots_tasks(GCTaskQueue* q);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  // This creates a list of GCTasks, one per thread, for marking objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  static void create_thread_roots_marking_tasks(GCTaskQueue* q);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
  // Apply "f->do_oop" to roots in all threads that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
  // are part of compiled frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
  static void compiled_frame_oops_do(OopClosure* f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
  static void convert_hcode_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
  static void restore_hcode_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
  // Sweeper
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  static void nmethods_do();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  static void gc_epilogue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
  static void gc_prologue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
  // Verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
  static void verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
  static void print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  static void print(bool print_stacks, bool internal_format) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
    // this function is only used by debug.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
    print_on(tty, print_stacks, internal_format, false /* no concurrent lock printed */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
  static void print_on_error(outputStream* st, Thread* current, char* buf, int buflen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
  // Get Java threads that are waiting to enter a monitor. If doLock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
  // is true, then Threads_lock is grabbed as needed. Otherwise, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
  // VM needs to be at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
  static GrowableArray<JavaThread*>* get_pending_threads(int count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    address monitor, bool doLock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
  // Get owning Java thread from the monitor's owner field. If doLock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
  // is true, then Threads_lock is grabbed as needed. Otherwise, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
  // VM needs to be at a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
  static JavaThread *owning_thread_from_monitor_owner(address owner,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
    bool doLock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
  // Number of threads on the active threads list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
  static int number_of_threads()                 { return _number_of_threads; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  // Number of non-daemon threads on the active threads list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
  static int number_of_non_daemon_threads()      { return _number_of_non_daemon_threads; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
  // Deoptimizes all frames tied to marked nmethods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
  static void deoptimized_wrt_marked_nmethods();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
// Thread iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
class ThreadClosure: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
  virtual void do_thread(Thread* thread) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
class SignalHandlerMark: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  Thread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  SignalHandlerMark(Thread* t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
    _thread = t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
    if (_thread) _thread->enter_signal_handler();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
  ~SignalHandlerMark() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
    if (_thread) _thread->leave_signal_handler();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
    _thread = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
// ParkEvents are type-stable and immortal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
// Lifecycle: Once a ParkEvent is associated with a thread that ParkEvent remains
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
// associated with the thread for the thread's entire lifetime - the relationship is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
// stable. A thread will be associated at most one ParkEvent.  When the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
// expires, the ParkEvent moves to the EventFreeList.  New threads attempt to allocate from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
// the EventFreeList before creating a new Event.  Type-stability frees us from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
// worrying about stale Event or Thread references in the objectMonitor subsystem.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
// (A reference to ParkEvent is always valid, even though the event may no longer be associated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
// with the desired or expected thread.  A key aspect of this design is that the callers of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
// park, unpark, etc must tolerate stale references and spurious wakeups).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
// Only the "associated" thread can block (park) on the ParkEvent, although
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
// any other thread can unpark a reachable parkevent.  Park() is allowed to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
// return spuriously.  In fact park-unpark a really just an optimization to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
// avoid unbounded spinning and surrender the CPU to be a polite system citizen.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
// A degenerate albeit "impolite" park-unpark implementation could simply return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
// See http://blogs.sun.com/dave for more details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
// Eventually I'd like to eliminate Events and ObjectWaiters, both of which serve as
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
// thread proxies, and simply make the THREAD structure type-stable and persistent.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
// Currently, we unpark events associated with threads, but ideally we'd just
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
// unpark threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
// The base-class, PlatformEvent, is platform-specific while the ParkEvent is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
// platform-independent.  PlatformEvent provides park(), unpark(), etc., and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
// is abstract -- that is, a PlatformEvent should never be instantiated except
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
// as part of a ParkEvent.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
// Equivalently we could have defined a platform-independent base-class that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
// exported Allocate(), Release(), etc.  The platform-specific class would extend
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
// that base-class, adding park(), unpark(), etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
// A word of caution: The JVM uses 2 very similar constructs:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
// 1. ParkEvent are used for Java-level "monitor" synchronization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
// 2. Parkers are used by JSR166-JUC park-unpark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
// We'll want to eventually merge these redundant facilities and use ParkEvent.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
class ParkEvent : public os::PlatformEvent {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
    ParkEvent * FreeNext ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
    // Current association
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
    Thread * AssociatedWith ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
    intptr_t RawThreadIdentity ;        // LWPID etc
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
    volatile int Incarnation ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
    // diagnostic : keep track of last thread to wake this thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
    // this is useful for construction of dependency graphs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
    void * LastWaker ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
    // MCS-CLH list linkage and Native Mutex/Monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
    ParkEvent * volatile ListNext ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
    ParkEvent * volatile ListPrev ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
    volatile intptr_t OnList ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
    volatile int TState ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
    volatile int Notified ;             // for native monitor construct
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
    volatile int IsWaiting ;            // Enqueued on WaitSet
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
    static ParkEvent * volatile FreeList ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
    static volatile int ListLock ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
    // It's prudent to mark the dtor as "private"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
    // ensuring that it's not visible outside the package.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
    // Unfortunately gcc warns about such usage, so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
    // we revert to the less desirable "protected" visibility.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
    // The other compilers accept private dtors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  protected:        // Ensure dtor is never invoked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
    ~ParkEvent() { guarantee (0, "invariant") ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
    ParkEvent() : PlatformEvent() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
       AssociatedWith = NULL ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
       FreeNext       = NULL ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
       ListNext       = NULL ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
       ListPrev       = NULL ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
       OnList         = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
       TState         = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
       Notified       = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
       IsWaiting      = 0 ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
    // We use placement-new to force ParkEvent instances to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
    // aligned on 256-byte address boundaries.  This ensures that the least
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
    // significant byte of a ParkEvent address is always 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
    void * operator new (size_t sz) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
    void operator delete (void * a) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
    static ParkEvent * Allocate (Thread * t) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
    static void Release (ParkEvent * e) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
} ;