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

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 // osThread.hpp).
 //
 // 2. It would be more natural if set_external_suspend() is private and
 // part of java_suspend(), but that probably would affect the suspend/query
 // performance. Need more investigation on this.
-//
 // suspend/resume lock: used for self-suspend
 Monitor* _SR_lock;
 protected:
 size_t  stack_size() const           { return _stack_size; }
 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 */
+// QQQ this has knowledge of direction, ought to be a stack method
 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; }
 // ThreadLocalStorage::thread is warm -- it's called > 16K times in the same
 // period.   This is inlined in thread_<os_family>.inline.hpp.
 inline Thread* Thread::current() {
 #ifdef ASSERT
 // This function is very high traffic. Define PARANOID to enable expensive
 // asserts.
 #ifdef PARANOID
 // Signal handler should call ThreadLocalStorage::get_thread_slow()
 Thread* t = ThreadLocalStorage::get_thread_slow();
 assert(t != NULL && !t->is_inside_signal_handler(),
 "Don't use Thread::current() inside signal handler");
 // suspend/resume support
 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
+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
 intptr_t _target;
 intptr_t _instruction;
 const char*  _file;
 int _line;
 }   _jmp_ring[jump_ring_buffer_size];
-#endif /* PRODUCT */
+#endif // PRODUCT
 #if INCLUDE_ALL_GCS
 // Support for G1 barriers
 ObjPtrQueue _satb_mark_queue;          // Thread-local log for SATB barrier.
 bool is_ext_suspend_completed_with_lock(uint32_t *bits) {
 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 // Warning: is_ext_suspend_completed() may temporarily drop the
 // SR_lock to allow the thread to reach a stable thread state if
 // it is currently in a transient thread state.
-return is_ext_suspend_completed(false /*!called_by_wait */,
+return is_ext_suspend_completed(false /* !called_by_wait */,
 SuspendRetryDelay, bits);
 }
 // We cannot allow wait_for_ext_suspend_completion() to run forever or
 // we could hang. SuspendRetryCount and SuspendRetryDelay are normally
 return (_suspend_flags & _external_suspend) != 0;
 }
 // Whenever a thread transitions from native to vm/java it must suspend
 // if external|deopt suspend is present.
 bool is_suspend_after_native() const {
-return (_suspend_flags & (_external_suspend | _deopt_suspend) ) != 0;
+return (_suspend_flags & (_external_suspend | _deopt_suspend)) != 0;
 }
 // external suspend request is completed
 bool is_ext_suspended() const {
 return (_suspend_flags & _ext_suspended) != 0;
 return is_ext_suspended() || is_external_suspend();
 }
 bool is_suspend_equivalent() const             { return _suspend_equivalent; }
-void set_suspend_equivalent()                  { _suspend_equivalent = true; };
+void set_suspend_equivalent()                  { _suspend_equivalent = true; }
-void clear_suspend_equivalent()                { _suspend_equivalent = false; };
+void clear_suspend_equivalent()                { _suspend_equivalent = false; }
 // Thread.stop support
 void send_thread_stop(oop throwable);
 AsyncRequests clear_special_runtime_exit_condition() {
 AsyncRequests x = _special_runtime_exit_condition;
 set_exception_pc(NULL);
 }
 // Stack overflow support
 inline size_t stack_available(address cur_sp);
-address stack_yellow_zone_base()
+address stack_yellow_zone_base() {
-{ return (address)(stack_base() - (stack_size() - (stack_red_zone_size() + stack_yellow_zone_size()))); }
+return (address)(stack_base() -
-size_t  stack_yellow_zone_size()
+(stack_size() -
-{ return StackYellowPages * os::vm_page_size(); }
+(stack_red_zone_size() + stack_yellow_zone_size())));
-address stack_red_zone_base()
+}
-{ return (address)(stack_base() - (stack_size() - stack_red_zone_size())); }
+size_t  stack_yellow_zone_size() {
-size_t stack_red_zone_size()
+return StackYellowPages * os::vm_page_size();
-{ return StackRedPages * os::vm_page_size(); }
+}
-bool in_stack_yellow_zone(address a)
+address stack_red_zone_base() {
-{ return (a <= stack_yellow_zone_base()) && (a >= stack_red_zone_base()); }
+return (address)(stack_base() - (stack_size() - stack_red_zone_size()));
-bool in_stack_red_zone(address a)
+}
-{ return (a <= stack_red_zone_base()) && (a >= (address)((intptr_t)stack_base() - stack_size())); }
+size_t stack_red_zone_size() { return StackRedPages * os::vm_page_size(); }
+bool in_stack_yellow_zone(address a) {
+return (a <= stack_yellow_zone_base()) && (a >= stack_red_zone_base());
+}
+bool in_stack_red_zone(address a) {
+return (a <= stack_red_zone_base()) &&
+(a >= (address)((intptr_t)stack_base() - stack_size()));
+}
 void create_stack_guard_pages();
 void remove_stack_guard_pages();
 void enable_stack_yellow_zone();
 void clr_do_not_unlock(void)                   { _do_not_unlock_if_synchronized = false; }
 bool do_not_unlock(void)                       { return _do_not_unlock_if_synchronized; }
 #ifndef PRODUCT
 void record_jump(address target, address instr, const char* file, int line);
-#endif /* PRODUCT */
+#endif // PRODUCT
 // For assembly stub generation
 static ByteSize threadObj_offset()             { return byte_offset_of(JavaThread, _threadObj); }
 #ifndef PRODUCT
 static ByteSize jmp_ring_index_offset()        { return byte_offset_of(JavaThread, _jmp_ring_index); }
 static ByteSize jmp_ring_offset()              { return byte_offset_of(JavaThread, _jmp_ring); }
-#endif /* PRODUCT */
+#endif // PRODUCT
 static ByteSize jni_environment_offset()       { return byte_offset_of(JavaThread, _jni_environment); }
 static ByteSize last_Java_sp_offset() {
 return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_sp_offset();
 }
 static ByteSize last_Java_pc_offset() {
 }
 // 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 ||
+void enter_critical() {
-Thread::current()->is_VM_thread() && SafepointSynchronize::is_synchronizing(),
+assert(Thread::current() == this ||
-"this must be current thread or synchronizing");
+(Thread::current()->is_VM_thread() &&
-_jni_active_critical++; }
+SafepointSynchronize::is_synchronizing()),
-void exit_critical()  { assert(Thread::current() == this,
+"this must be current thread or synchronizing");
-"this must be current thread");
+_jni_active_critical++;
-_jni_active_critical--;
+}
-assert(_jni_active_critical >= 0,
+void exit_critical() {
-"JNI critical nesting problem?"); }
+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; }
 // Misc. operations
 char* name() const { return (char*)get_thread_name(); }
 void print_on(outputStream* st) const;
 void print_value();
-void print_thread_state_on(outputStream* ) const      PRODUCT_RETURN;
+void print_thread_state_on(outputStream*) const      PRODUCT_RETURN;
-void print_thread_state() 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
 // Get/set the thread's compilation environment.
 ciEnv*        env()                            { return _env; }
 void          set_env(ciEnv* env)              { _env = env; }
 BufferBlob*   get_buffer_blob() const          { return _buffer_blob; }
-void          set_buffer_blob(BufferBlob* b)   { _buffer_blob = b; };
+void          set_buffer_blob(BufferBlob* b)   { _buffer_blob = b; }
 // Get/set the thread's logging information
 CompileLog*   log()                            { return _log; }
 void          init_log(CompileLog* log) {
 // Set once, for good.

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 26834	41332d860d6a