jdk-sandbox: comparison hotspot/src/share/vm/runtime/thread.hpp

equal deleted inserted replaced

-:8f17e084029b
+:a02753d5a0b2
 void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
 return allocate(size, false); }
 void  operator delete(void* p);
 protected:
 static void* allocate(size_t size, bool throw_excpt, MEMFLAGS flags = mtThread);
 private:
 // ***************************************************************
 // Suspend and resume support
 // ***************************************************************
 // The parity of the last strong_roots iteration in which this thread was
 // claimed as a task.
 jint _oops_do_parity;
 public:
 void set_last_handle_mark(HandleMark* mark)   { _last_handle_mark = mark; }
 HandleMark* last_handle_mark() const          { return _last_handle_mark; }
 private:
 // debug support for checking if code does allow safepoints or not
 // GC points in the VM can happen because of allocation, invoking a VM operation, or blocking on
 // mutex, or blocking on an object synchronizer (Java locking).
 // If !allow_safepoint(), then an assertion failure will happen in any of the above cases
 //   Used by JavaThread::oops_do.
 // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames
 virtual void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
 // Handles the parallel case for the method below.
 private:
 bool claim_oops_do_par_case(int collection_parity);
 public:
 // Requires that "collection_parity" is that of the current roots
 // iteration.  If "is_par" is false, sets the parity of "this" to
 // "collection_parity", and returns "true".  If "is_par" is true,
 // uses an atomic instruction to set the current threads parity to
 // "collection_parity", if it is not already.  Returns "true" iff the
 virtual void print_on(outputStream* st) const;
 };
 // Worker threads are named and have an id of an assigned work.
 class WorkerThread: public NamedThread {
 private:
 uint _id;
 public:
 WorkerThread() : _id(0)               { }
 virtual bool is_Worker_thread() const { return true; }
 virtual WorkerThread* as_Worker_thread() const {
 assert(is_Worker_thread(), "Dubious cast to WorkerThread*?");
 volatile bool         _suspend_equivalent;     // Suspend equivalent condition
 jint                  _in_deopt_handler;       // count of deoptimization
 // handlers thread is in
 volatile bool         _doing_unsafe_access;    // Thread may fault due to unsafe access
 bool                  _do_not_unlock_if_synchronized; // Do not unlock the receiver of a synchronized method (since it was
 // never locked) when throwing an exception. Used by interpreter only.
 // JNI attach states:
 enum JNIAttachStates {
 _not_attaching_via_jni = 1,  // thread is not attaching via JNI
 _attaching_via_jni,          // thread is attaching via JNI
 int _popframe_condition;
 #ifndef PRODUCT
 int _jmp_ring_index;
 struct {
 // We use intptr_t instead of address so debugger doesn't try and display strings
 intptr_t _target;
 intptr_t _instruction;
 const char*  _file;
 int _line;
 }   _jmp_ring[jump_ring_buffer_size];
 #endif /* PRODUCT */
 #if INCLUDE_ALL_GCS
 // Support for G1 barriers
 // Special method to handle a pending external suspend request
 // when a suspend equivalent condition lifts.
 bool handle_special_suspend_equivalent_condition() {
 assert(is_suspend_equivalent(),
 "should only be called in a suspend equivalence condition");
 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 bool ret = is_external_suspend();
 if (!ret) {
 // not about to self-suspend so clear suspend equivalence
 clear_suspend_equivalent();
 static JavaThread* thread_from_jni_environment(JNIEnv* env) {
 JavaThread *thread_from_jni_env = (JavaThread*)((intptr_t)env - in_bytes(jni_environment_offset()));
 // Only return NULL if thread is off the thread list; starting to
 // exit should not return NULL.
 if (thread_from_jni_env->is_terminated()) {
 thread_from_jni_env->block_if_vm_exited();
 return NULL;
 } else {
 return thread_from_jni_env;
 }
 }
 // JNI critical regions. These can nest.
 bool in_critical()    { return _jni_active_critical > 0; }
 bool in_last_critical()  { return _jni_active_critical == 1; }
 void enter_critical() { assert(Thread::current() == this ||
 Thread::current()->is_VM_thread() && SafepointSynchronize::is_synchronizing(),
 "this must be current thread or synchronizing");
 _jni_active_critical++; }
 void exit_critical()  { assert(Thread::current() == this,
 "this must be current thread");
 _jni_active_critical--;
 assert(_jni_active_critical >= 0,
 "JNI critical nesting problem?"); }
 // Checked JNI, is the programmer required to check for exceptions, specify which function name
 bool is_pending_jni_exception_check() const { return _pending_jni_exception_check_fn != NULL; }
 void clear_pending_jni_exception_check() { _pending_jni_exception_check_fn = NULL; }
 const char* get_pending_jni_exception_check() const { return _pending_jni_exception_check_fn; }
 void print_thread_state_on(outputStream* ) const      PRODUCT_RETURN;
 void print_thread_state() const                       PRODUCT_RETURN;
 void print_on_error(outputStream* st, char* buf, int buflen) const;
 void verify();
 const char* get_thread_name() const;
 private:
 // factor out low-level mechanics for use in both normal and error cases
 const char* get_thread_name_string(char* buf = NULL, int buflen = 0) const;
 public:
 const char* get_threadgroup_name() const;
 const char* get_parent_name() const;
 // Accessing frames
 frame last_frame() {
 void deoptimized_wrt_marked_nmethods();
 // Profiling operation (see fprofile.cpp)
 public:
 bool profile_last_Java_frame(frame* fr);
 private:
 ThreadProfiler* _thread_profiler;
 private:
 friend class FlatProfiler;                    // uses both [gs]et_thread_profiler.
 friend class FlatProfilerTask;                // uses get_thread_profiler.
 friend class ThreadProfilerMark;              // uses get_thread_profiler.
 ThreadProfiler* get_thread_profiler()         { return _thread_profiler; }
 ThreadProfiler* set_thread_profiler(ThreadProfiler* tp) {
 ThreadProfiler* result = _thread_profiler;
 _thread_profiler = tp;
 return result;
 }
 public:
 // Returns the running thread as a JavaThread
 static inline JavaThread* current();
 protected:
 bool         _blocked_on_compilation;
 // JSR166 per-thread parker
 private:
 Parker*    _parker;
 public:
 Parker*     parker() { return _parker; }
 // Biased locking support
 private:
 GrowableArray<MonitorInfo*>* _cached_monitor_info;
 public:
 GrowableArray<MonitorInfo*>* cached_monitor_info() { return _cached_monitor_info; }
 void set_cached_monitor_info(GrowableArray<MonitorInfo*>* info) { _cached_monitor_info = info; }
 // clearing/querying jni attach status
 bool is_attaching_via_jni() const { return _jni_attach_state == _attaching_via_jni; }
 bool has_attached_via_jni() const { return is_attaching_via_jni() || _jni_attach_state == _attached_via_jni; }
 inline void set_done_attaching_via_jni();
 private:
 // This field is used to determine if a thread has claimed
 // a par_id: it is UINT_MAX if the thread has not claimed a par_id;
 // otherwise its value is the par_id that has been claimed.
 uint _claimed_par_id;
 public:
 uint get_claimed_par_id() { return _claimed_par_id; }
 void set_claimed_par_id(uint id) { _claimed_par_id = id; }
 };
 // Inline implementation of JavaThread::current
 // Apply "f->do_oop" to all root oops in "this".
 // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames
 void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
 #ifndef PRODUCT
 private:
 IdealGraphPrinter *_ideal_graph_printer;
 public:
 IdealGraphPrinter *ideal_graph_printer()                       { return _ideal_graph_printer; }
 void set_ideal_graph_printer(IdealGraphPrinter *n)             { _ideal_graph_printer = n; }
 #endif
 // Get/set the thread's current task
 // Get Java threads that are waiting to enter a monitor. If doLock
 // is true, then Threads_lock is grabbed as needed. Otherwise, the
 // VM needs to be at a safepoint.
 static GrowableArray<JavaThread*>* get_pending_threads(int count,
 address monitor, bool doLock);
 // Get owning Java thread from the monitor's owner field. If doLock
 // is true, then Threads_lock is grabbed as needed. Otherwise, the
 // VM needs to be at a safepoint.
 static JavaThread *owning_thread_from_monitor_owner(address owner,
 bool doLock);
 // Number of threads on the active threads list
 static int number_of_threads()                 { return _number_of_threads; }
 // Number of non-daemon threads on the active threads list
 static int number_of_non_daemon_threads()      { return _number_of_non_daemon_threads; }
 public:
 virtual void do_thread(Thread* thread) = 0;
 };
 class SignalHandlerMark: public StackObj {
 private:
 Thread* _thread;
 public:
 SignalHandlerMark(Thread* t) {
 _thread = t;
 if (_thread) _thread->enter_signal_handler();
 }
 ~SignalHandlerMark() {

changeset 26683	a02753d5a0b2
parent 25946	1572c9f03fb9
child 26684	d1221849ea3d