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

equal deleted inserted replaced

-:ea246151be08
+:a87f2e7a527c
 #define SHARE_VM_RUNTIME_THREADSMR_HPP
 #include "memory/allocation.hpp"
 #include "runtime/timer.hpp"
+class JavaThread;
+class Monitor;
+class outputStream;
+class Thread;
 class ThreadClosure;
 // Thread Safe Memory Reclamation (Thread-SMR) support.
 //
 // ThreadsListHandles are used to safely perform operations on one or more
 // SMR Support for the Threads class.
 //
 class ThreadsSMRSupport : AllStatic {
+friend class SafeThreadsListPtr;  // for _nested_thread_list_max, delete_notify(), release_stable_list_wake_up() access
 // The coordination between ThreadsSMRSupport::release_stable_list() and
 // ThreadsSMRSupport::smr_delete() uses the delete_lock in order to
 // reduce the traffic on the Threads_lock.
 static Monitor*              _delete_lock;
 // The '_cnt', '_max' and '_times" fields are enabled via
 static void free_list(ThreadsList* threads);
 static void inc_deleted_thread_cnt();
 static void inc_java_thread_list_alloc_cnt();
 static void inc_tlh_cnt();
 static bool is_a_protected_JavaThread(JavaThread *thread);
-static void release_stable_list_fast_path(Thread *self);
+static void release_stable_list_wake_up(bool is_nested);
-static void release_stable_list_nested_path(Thread *self);
-static void release_stable_list_wake_up(char *log_str);
 static void set_delete_notify();
 static void threads_do(ThreadClosure *tc);
 static void threads_do(ThreadClosure *tc, ThreadsList *list);
 static void update_deleted_thread_time_max(uint new_value);
 static void update_java_thread_list_max(uint new_value);
 static void update_tlh_time_max(uint new_value);
-static void verify_hazard_pointer_scanned(Thread *self, ThreadsList *threads);
+static void verify_hazard_ptr_scanned(Thread *self, ThreadsList *threads);
 static ThreadsList* xchg_java_thread_list(ThreadsList* new_list);
 public:
-static ThreadsList *acquire_stable_list(Thread *self, bool is_ThreadsListSetter);
 static void add_thread(JavaThread *thread);
 static ThreadsList* get_java_thread_list();
 static bool is_a_protected_JavaThread_with_lock(JavaThread *thread);
-static void release_stable_list(Thread *self);
 static void remove_thread(JavaThread *thread);
 static void smr_delete(JavaThread *thread);
 static void update_tlh_stats(uint millis);
 // Logging and printing support:
 static void log_statistics();
 static void print_info_elements_on(outputStream* st, ThreadsList* t_list);
 static void print_info_on(outputStream* st);
+static void print_info_on(const Thread* thread, outputStream* st);
 };
 // A fast list of JavaThreads.
 //
 class ThreadsList : public CHeapObj<mtThread> {
-friend class ThreadsSMRSupport;  // for next_list(), set_next_list() access
+friend class SafeThreadsListPtr;  // for {dec,inc}_nested_handle_cnt() access
+friend class ThreadsSMRSupport;  // for _nested_handle_cnt, {add,remove}_thread(), {,set_}next_list() access
 const uint _length;
 ThreadsList* _next_list;
 JavaThread *const *const _threads;
+volatile intx _nested_handle_cnt;
 template <class T>
 void threads_do_dispatch(T *cl, JavaThread *const thread) const;
 ThreadsList *next_list() const        { return _next_list; }
 void set_next_list(ThreadsList *list) { _next_list = list; }
+void inc_nested_handle_cnt();
+void dec_nested_handle_cnt();
 static ThreadsList* add_thread(ThreadsList* list, JavaThread* java_thread);
 static ThreadsList* remove_thread(ThreadsList* list, JavaThread* java_thread);
 public:
 int find_index_of_JavaThread(JavaThread* target);
 JavaThread* find_JavaThread_from_java_tid(jlong java_tid) const;
 bool includes(const JavaThread * const p) const;
 };
-// Linked list of ThreadsLists to support nested ThreadsListHandles.
+// An abstract safe ptr to a ThreadsList comprising either a stable hazard ptr
-class NestedThreadsList : public CHeapObj<mtThread> {
+// for leaves, or a retained reference count for nested uses. The user of this
-ThreadsList*const _t_list;
+// API does not need to know which mechanism is providing the safety.
-NestedThreadsList* _next;
+class SafeThreadsListPtr {
+friend class ThreadsListSetter;
-public:
-NestedThreadsList(ThreadsList* t_list) : _t_list(t_list) {
+SafeThreadsListPtr* _previous;
-assert(Threads_lock->owned_by_self(),
+Thread*                 _thread;
-"must own Threads_lock for saved t_list to be valid.");
+ThreadsList*            _list;
-}
+bool                    _has_ref_count;
+bool                    _needs_release;
-ThreadsList* t_list() { return _t_list; }
-NestedThreadsList* next() { return _next; }
+void acquire_stable_list();
-void set_next(NestedThreadsList* value) { _next = value; }
+void acquire_stable_list_fast_path();
+void acquire_stable_list_nested_path();
+void release_stable_list();
+void verify_hazard_ptr_scanned();
+public:
+// Constructor that attaches the list onto a thread.
+SafeThreadsListPtr(Thread *thread, bool acquire) :
+_previous(NULL),
+_thread(thread),
+_list(NULL),
+_has_ref_count(false),
+_needs_release(false)
+{
+if (acquire) {
+acquire_stable_list();
+}
+}
+// Constructor that transfers ownership of the pointer.
+SafeThreadsListPtr(SafeThreadsListPtr& other) :
+_previous(other._previous),
+_thread(other._thread),
+_list(other._list),
+_has_ref_count(other._has_ref_count),
+_needs_release(other._needs_release)
+{
+other._needs_release = false;
+}
+~SafeThreadsListPtr() {
+if (_needs_release) {
+release_stable_list();
+}
+}
+ThreadsList* list() const { return _list; }
+SafeThreadsListPtr* previous() const { return _previous; }
+void print_on(outputStream* st);
 };
 // A helper to optionally set the hazard ptr in ourself. This helper can
 // be used by ourself or by another thread. If the hazard ptr is set(),
 // then the destructor will release it.
 //
 class ThreadsListSetter : public StackObj {
 private:
-bool _target_needs_release;  // needs release only when set()
+SafeThreadsListPtr _list_ptr;
-Thread * _target;
+public:
-public:
+ThreadsListSetter() : _list_ptr(Thread::current(), /* acquire */ false) {}
-ThreadsListSetter() : _target_needs_release(false), _target(Thread::current()) {
+ThreadsList* list() { return _list_ptr.list(); }
-}
+void set() { _list_ptr.acquire_stable_list(); }
-~ThreadsListSetter();
+bool is_set() { return _list_ptr._needs_release; }
-ThreadsList* list();
-void set();
-bool target_needs_release() { return _target_needs_release; }
 };
 // This stack allocated ThreadsListHandle keeps all JavaThreads in the
 // ThreadsList from being deleted until it is safe.
 //
 class ThreadsListHandle : public StackObj {
-ThreadsList * _list;
+SafeThreadsListPtr _list_ptr;
-Thread *const _self;
 elapsedTimer _timer;  // Enabled via -XX:+EnableThreadSMRStatistics.
 public:
 ThreadsListHandle(Thread *self = Thread::current());
 ~ThreadsListHandle();
 ThreadsList *list() const {
-return _list;
+return _list_ptr.list();
 }
 template <class T>
 void threads_do(T *cl) const {
-return _list->threads_do(cl);
+return list()->threads_do(cl);
 }
 bool cv_internal_thread_to_JavaThread(jobject jthread, JavaThread ** jt_pp, oop * thread_oop_p);
 bool includes(JavaThread* p) {
-return _list->includes(p);
+return list()->includes(p);
 }
 uint length() const {
-return _list->length();
+return list()->length();
 }
 };
 // This stack allocated JavaThreadIterator is used to walk the
 // specified ThreadsList using the following style:

changeset 49956	a87f2e7a527c
parent 49756	129d60b5dac7
child 52448	bc5c7f63dbae