jdk8-mips64-public/hotspot: comparison src/share/vm/runtime/thread.hpp

-:274a1ea904c8
+:fd44df5e3bc3
 #include "runtime/safepoint.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/threadLocalStorage.hpp"
 #include "runtime/thread_ext.hpp"
 #include "runtime/unhandledOops.hpp"
-#include "trace/traceBackend.hpp"
-#include "trace/traceMacros.hpp"
 #include "utilities/exceptions.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/top.hpp"
 #if INCLUDE_ALL_GCS
 #include "gc_implementation/g1/dirtyCardQueue.hpp"
 #include "gc_implementation/g1/satbQueue.hpp"
 #endif // INCLUDE_ALL_GCS
 #ifdef TARGET_ARCH_zero
 # include "stack_zero.hpp"
+#endif
+#if INCLUDE_JFR
+#include "jfr/support/jfrThreadExtension.hpp"
 #endif
 class ThreadSafepointState;
 class ThreadProfiler;
 _external_suspend       = 0x20000000U, // thread is asked to self suspend
 _ext_suspended          = 0x40000000U, // thread has self-suspended
 _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt
 _has_async_exception    = 0x00000001U, // there is a pending async exception
-_critical_native_unlock = 0x00000002U  // Must call back to unlock JNI critical lock
+_critical_native_unlock = 0x00000002U, // Must call back to unlock JNI critical lock
+JFR_ONLY(_trace_flag    = 0x00000004U)  // call jfr tracing
 };
 // various suspension related flags - atomically updated
 // overloaded for async exception checking in check_special_condition_for_native_trans.
 volatile uint32_t _suspend_flags;
 // the Java heap
 // Thread-local buffer used by MetadataOnStackMark.
 MetadataOnStackBuffer* _metadata_on_stack_buffer;
-TRACE_DATA _trace_data;                       // Thread-local data for tracing
+JFR_ONLY(DEFINE_THREAD_LOCAL_FIELD_JFR;)      // Thread-local data for jfr
 ThreadExt _ext;
 int   _vm_operation_started_count;            // VM_Operation support
 int   _vm_operation_completed_count;          // VM_Operation support
 jlong allocated_bytes()               { return _allocated_bytes; }
 void set_allocated_bytes(jlong value) { _allocated_bytes = value; }
 void incr_allocated_bytes(jlong size) { _allocated_bytes += size; }
 inline jlong cooked_allocated_bytes();
-TRACE_DATA* trace_data()              { return &_trace_data; }
+JFR_ONLY(DEFINE_THREAD_LOCAL_ACCESSOR_JFR;)
+JFR_ONLY(DEFINE_TRACE_SUSPEND_FLAG_METHODS)
 const ThreadExt& ext() const          { return _ext; }
 ThreadExt& ext()                      { return _ext; }
 // VM operation support
 void    set_stack_size(size_t size)  { _stack_size = size; }
 void    record_stack_base_and_size();
 bool    on_local_stack(address adr) const {
 /* QQQ this has knowledge of direction, ought to be a stack method */
-return (_stack_base >= adr && adr >= (_stack_base - _stack_size));
+return (_stack_base > adr && adr >= (_stack_base - _stack_size));
 }
 uintptr_t self_raw_id()                    { return _self_raw_id; }
 void      set_self_raw_id(uintptr_t value) { _self_raw_id = value; }
 #undef TLAB_FIELD_OFFSET
 static ByteSize allocated_bytes_offset()       { return byte_offset_of(Thread, _allocated_bytes ); }
+JFR_ONLY(DEFINE_THREAD_LOCAL_OFFSET_JFR;)
 public:
 volatile intptr_t _Stalled ;
 volatile int _TypeTag ;
 ParkEvent * _ParkEvent ;                     // for synchronized()
 ParkEvent * _SleepEvent ;                    // for Thread.sleep
 private:
 static WatcherThread* _watcher_thread;
 static bool _startable;
 volatile static bool _should_terminate; // updated without holding lock
-os::WatcherThreadCrashProtection* _crash_protection;
 public:
 enum SomeConstants {
 delay_interval = 10                          // interrupt delay in milliseconds
 };
 static void start();
 static void stop();
 // Only allow start once the VM is sufficiently initialized
 // Otherwise the first task to enroll will trigger the start
 static void make_startable();
-void set_crash_protection(os::WatcherThreadCrashProtection* crash_protection) {
-assert(Thread::current()->is_Watcher_thread(), "Can only be set by WatcherThread");
-_crash_protection = crash_protection;
-}
-bool has_crash_protection() const { return _crash_protection != NULL; }
-os::WatcherThreadCrashProtection* crash_protection() const { return _crash_protection; }
 private:
 int sleep() const;
 };

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/runtime/thread.hpp

src/share/vm/runtime/thread.hpp