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

equal deleted inserted replaced

-:bf3518bba285
+:2a6c7c7b30a7
 //   - WatcherThread
 class Thread: public ThreadShadow {
 friend class VMStructs;
 private:
+#ifndef USE_LIBRARY_BASED_TLS_ONLY
+// Current thread is maintained as a thread-local variable
+static THREAD_LOCAL_DECL Thread* _thr_current;
+#endif
 // Exception handling
 // (Note: _pending_exception and friends are in ThreadShadow)
 //oop       _pending_exception;                // pending exception for current thread
 // const char* _exception_file;                   // file information for exception (debugging only)
 // int         _exception_line;                   // line information for exception (debugging only)
 NOT_PRODUCT(bool _skip_gcalot;)               // Should we elide gc-a-lot?
 friend class No_Alloc_Verifier;
 friend class No_Safepoint_Verifier;
 friend class Pause_No_Safepoint_Verifier;
-friend class ThreadLocalStorage;
 friend class GC_locker;
 ThreadLocalAllocBuffer _tlab;                 // Thread-local eden
 jlong _allocated_bytes;                       // Cumulative number of bytes allocated on
 // the Java heap
 // Constructor
 Thread();
 virtual ~Thread();
-// initializtion
+// Manage Thread::current()
-void initialize_thread_local_storage();
+void initialize_thread_current();
+private:
+void clear_thread_current(); // needed for detaching JNI threads
+public:
 // thread entry point
 virtual void run();
 // Testers
 virtual bool is_VM_thread()       const            { return false; }
 // Casts
 virtual WorkerThread* as_Worker_thread() const     { return NULL; }
 virtual char* name() const { return (char*)"Unknown thread"; }
-// Returns the current thread
+// Returns the current thread (ASSERTS if NULL)
 static inline Thread* current();
-// ... without having to include thread.inline.hpp.
+// Returns the current thread, or NULL if not attached
-static Thread* current_noinline();
+static inline Thread* current_or_null();
+// Returns the current thread, or NULL if not attached, and is
+// safe for use from signal-handlers
+static inline Thread* current_or_null_safe();
 // Common thread operations
 static void set_priority(Thread* thread, ThreadPriority priority);
 static ThreadPriority get_priority(const Thread* const thread);
 static void start(Thread* thread);
 static void muxAcquireW(volatile intptr_t * Lock, ParkEvent * ev);
 static void muxRelease(volatile intptr_t * Lock);
 };
 // Inline implementation of Thread::current()
-// Thread::current is "hot" it's called > 128K times in the 1st 500 msecs of
-// startup.
-// 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
+Thread* current = current_or_null();
-// This function is very high traffic. Define PARANOID to enable expensive
+assert(current != NULL, "Thread::current() called on detached thread");
-// asserts.
+return current;
-#ifdef PARANOID
+}
-// Signal handler should call ThreadLocalStorage::get_thread_slow()
-Thread* t = ThreadLocalStorage::get_thread_slow();
+inline Thread* Thread::current_or_null() {
-assert(t != NULL && !t->is_inside_signal_handler(),
+#ifndef USE_LIBRARY_BASED_TLS_ONLY
-"Don't use Thread::current() inside signal handler");
+return _thr_current;
-#endif
+#else
-#endif
+return ThreadLocalStorage::thread();
-Thread* thread = ThreadLocalStorage::thread();
+#endif
-assert(thread != NULL, "just checking");
+}
-return thread;
+inline Thread* Thread::current_or_null_safe() {
+return ThreadLocalStorage::thread();
 }
 // Name support for threads.  non-JavaThread subclasses with multiple
 // uniquely named instances should derive from this.
 class NamedThread: public Thread {
 void set_claimed_par_id(uint id) { _claimed_par_id = id; }
 };
 // Inline implementation of JavaThread::current
 inline JavaThread* JavaThread::current() {
-Thread* thread = ThreadLocalStorage::thread();
+Thread* thread = Thread::current();
-assert(thread != NULL && thread->is_Java_thread(), "just checking");
+assert(thread->is_Java_thread(), "just checking");
 return (JavaThread*)thread;
 }
 inline CompilerThread* JavaThread::as_CompilerThread() {
 assert(is_Compiler_thread(), "just checking");

changeset 34633	2a6c7c7b30a7
parent 33792	2bae5bf9e431
child 34666	1c7168ea0034