archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 23:04:50 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8247878: Move Management strong oops to OopStorage

Browse source 
Use OopStorage for strong oops stored with memory and thread sampling and dumping, and remove oops_do and GC calls.

Reviewed-by: dholmes, kbarrett
This commit is contained in:
Coleen Phillimore 2020-07-20 07:50:27 -04:00
parent c7d84850bf
commit 99eccaf6ec
34 changed files with 134 additions and 264 deletions
Download patch file Download diff file Expand all files Collapse all files

128
src/hotspot/share/services/threadService.cpp
View file

@ -28,6 +28,7 @@
#include "memory/heapInspection.hpp"
#include "memory/oopFactory.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/objArrayKlass.hpp"
#include "oops/objArrayOop.inline.hpp"
@ -261,13 +262,6 @@ bool ThreadService::set_thread_allocated_memory_enabled(bool flag) {
return prev;
}
// GC support
void ThreadService::oops_do(OopClosure* f) {
for (ThreadDumpResult* dump = _threaddump_list; dump != NULL; dump = dump->next()) {
dump->oops_do(f);
}
}
void ThreadService::metadata_do(void f(Metadata*)) {
for (ThreadDumpResult* dump = _threaddump_list; dump != NULL; dump = dump->next()) {
dump->metadata_do(f);
@ -538,11 +532,6 @@ ThreadSnapshot* ThreadDumpResult::add_thread_snapshot() {
}
ThreadSnapshot* ThreadDumpResult::add_thread_snapshot(JavaThread* thread) {
// Note: it is very important that the ThreadSnapshot* gets linked before
// ThreadSnapshot::initialize gets called. This is to ensure that
// ThreadSnapshot::oops_do can get called prior to the field
// ThreadSnapshot::_threadObj being assigned a value (to prevent a dangling
// oop).
ThreadSnapshot* ts = new ThreadSnapshot();
link_thread_snapshot(ts);
ts->initialize(t_list(), thread);
@ -561,12 +550,6 @@ void ThreadDumpResult::link_thread_snapshot(ThreadSnapshot* ts) {
_last = ts;
}
void ThreadDumpResult::oops_do(OopClosure* f) {
for (ThreadSnapshot* ts = _snapshots; ts != NULL; ts = ts->next()) {
ts->oops_do(f);
}
}
void ThreadDumpResult::metadata_do(void f(Metadata*)) {
for (ThreadSnapshot* ts = _snapshots; ts != NULL; ts = ts->next()) {
ts->metadata_do(f);
@ -580,31 +563,31 @@ ThreadsList* ThreadDumpResult::t_list() {
StackFrameInfo::StackFrameInfo(javaVFrame* jvf, bool with_lock_info) {
_method = jvf->method();
_bci = jvf->bci();
_class_holder = _method->method_holder()->klass_holder();
_class_holder = OopHandle(Universe::vm_global(), _method->method_holder()->klass_holder());
_locked_monitors = NULL;
if (with_lock_info) {
ResourceMark rm;
GrowableArray<MonitorInfo*>* list = jvf->locked_monitors();
int length = list->length();
if (length > 0) {
_locked_monitors = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<oop>(length, mtServiceability);
_locked_monitors = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<OopHandle>(length, mtServiceability);
for (int i = 0; i < length; i++) {
MonitorInfo* monitor = list->at(i);
assert(monitor->owner() != NULL, "This monitor must have an owning object");
_locked_monitors->append(monitor->owner());
_locked_monitors->append(OopHandle(Universe::vm_global(), monitor->owner()));
}
}
}
}
void StackFrameInfo::oops_do(OopClosure* f) {
StackFrameInfo::~StackFrameInfo() {
if (_locked_monitors != NULL) {
int length = _locked_monitors->length();
for (int i = 0; i < length; i++) {
f->do_oop((oop*) _locked_monitors->adr_at(i));
for (int i = 0; i < _locked_monitors->length(); i++) {
_locked_monitors->at(i).release(Universe::vm_global());
}
delete _locked_monitors;
}
f->do_oop(&_class_holder);
_class_holder.release(Universe::vm_global());
}
void StackFrameInfo::metadata_do(void f(Metadata*)) {
@ -616,7 +599,7 @@ void StackFrameInfo::print_on(outputStream* st) const {
java_lang_Throwable::print_stack_element(st, method(), bci());
int len = (_locked_monitors != NULL ? _locked_monitors->length() : 0);
for (int i = 0; i < len; i++) {
oop o = _locked_monitors->at(i);
oop o = _locked_monitors->at(i).resolve();
st->print_cr("\t- locked <" INTPTR_FORMAT "> (a %s)", p2i(o), o->klass()->external_name());
}
@ -648,18 +631,25 @@ ThreadStackTrace::ThreadStackTrace(JavaThread* t, bool with_locked_monitors) {
_depth = 0;
_with_locked_monitors = with_locked_monitors;
if (_with_locked_monitors) {
_jni_locked_monitors = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<oop>(INITIAL_ARRAY_SIZE, mtServiceability);
_jni_locked_monitors = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<OopHandle>(INITIAL_ARRAY_SIZE, mtServiceability);
} else {
_jni_locked_monitors = NULL;
}
}
void ThreadStackTrace::add_jni_locked_monitor(oop object) {
_jni_locked_monitors->append(OopHandle(Universe::vm_global(), object));
}
ThreadStackTrace::~ThreadStackTrace() {
for (int i = 0; i < _frames->length(); i++) {
delete _frames->at(i);
}
delete _frames;
if (_jni_locked_monitors != NULL) {
for (int i = 0; i < _jni_locked_monitors->length(); i++) {
_jni_locked_monitors->at(i).release(Universe::vm_global());
}
delete _jni_locked_monitors;
}
}
@ -703,9 +693,9 @@ bool ThreadStackTrace::is_owned_monitor_on_stack(oop object) {
for (int depth = 0; depth < num_frames; depth++) {
StackFrameInfo* frame = stack_frame_at(depth);
int len = frame->num_locked_monitors();
GrowableArray<oop>* locked_monitors = frame->locked_monitors();
GrowableArray<OopHandle>* locked_monitors = frame->locked_monitors();
for (int j = 0; j < len; j++) {
oop monitor = locked_monitors->at(j);
oop monitor = locked_monitors->at(j).resolve();
assert(monitor != NULL, "must be a Java object");
if (monitor == object) {
found = true;
@ -738,18 +728,6 @@ void ThreadStackTrace::add_stack_frame(javaVFrame* jvf) {
_depth++;
}
void ThreadStackTrace::oops_do(OopClosure* f) {
int length = _frames->length();
for (int i = 0; i < length; i++) {
_frames->at(i)->oops_do(f);
}
length = (_jni_locked_monitors != NULL ? _jni_locked_monitors->length() : 0);
for (int j = 0; j < length; j++) {
f->do_oop((oop*) _jni_locked_monitors->adr_at(j));
}
}
void ThreadStackTrace::metadata_do(void f(Metadata*)) {
int length = _frames->length();
for (int i = 0; i < length; i++) {
@ -832,7 +810,7 @@ ThreadConcurrentLocks* ConcurrentLocksDump::thread_concurrent_locks(JavaThread*
void ConcurrentLocksDump::print_locks_on(JavaThread* t, outputStream* st) {
st->print_cr(" Locked ownable synchronizers:");
ThreadConcurrentLocks* tcl = thread_concurrent_locks(t);
GrowableArray<instanceOop>* locks = (tcl != NULL ? tcl->owned_locks() : NULL);
GrowableArray<OopHandle>* locks = (tcl != NULL ? tcl->owned_locks() : NULL);
if (locks == NULL || locks->is_empty()) {
st->print_cr("\t- None");
st->cr();
@ -840,7 +818,7 @@ void ConcurrentLocksDump::print_locks_on(JavaThread* t, outputStream* st) {
}
for (int i = 0; i < locks->length(); i++) {
instanceOop obj = locks->at(i);
oop obj = locks->at(i).resolve();
st->print_cr("\t- <" INTPTR_FORMAT "> (a %s)", p2i(obj), obj->klass()->external_name());
}
st->cr();
@ -848,23 +826,19 @@ void ConcurrentLocksDump::print_locks_on(JavaThread* t, outputStream* st) {
ThreadConcurrentLocks::ThreadConcurrentLocks(JavaThread* thread) {
_thread = thread;
_owned_locks = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<instanceOop>(INITIAL_ARRAY_SIZE, mtServiceability);
_owned_locks = new (ResourceObj::C_HEAP, mtServiceability) GrowableArray<OopHandle>(INITIAL_ARRAY_SIZE, mtServiceability);
_next = NULL;
}
ThreadConcurrentLocks::~ThreadConcurrentLocks() {
for (int i = 0; i < _owned_locks->length(); i++) {
_owned_locks->at(i).release(Universe::vm_global());
}
delete _owned_locks;
}
void ThreadConcurrentLocks::add_lock(instanceOop o) {
_owned_locks->append(o);
}
void ThreadConcurrentLocks::oops_do(OopClosure* f) {
int length = _owned_locks->length();
for (int i = 0; i < length; i++) {
f->do_oop((oop*) _owned_locks->adr_at(i));
}
_owned_locks->append(OopHandle(Universe::vm_global(), o));
}
ThreadStatistics::ThreadStatistics() {
@ -876,9 +850,12 @@ ThreadStatistics::ThreadStatistics() {
memset((void*) _perf_recursion_counts, 0, sizeof(_perf_recursion_counts));
}
oop ThreadSnapshot::threadObj() const { return _threadObj.resolve(); }
void ThreadSnapshot::initialize(ThreadsList * t_list, JavaThread* thread) {
_thread = thread;
_threadObj = thread->threadObj();
oop threadObj = thread->threadObj();
_threadObj = OopHandle(Universe::vm_global(), threadObj);
ThreadStatistics* stat = thread->get_thread_stat();
_contended_enter_ticks = stat->contended_enter_ticks();
@ -888,10 +865,13 @@ void ThreadSnapshot::initialize(ThreadsList * t_list, JavaThread* thread) {
_sleep_ticks = stat->sleep_ticks();
_sleep_count = stat->sleep_count();
_thread_status = java_lang_Thread::get_thread_status(_threadObj);
_thread_status = java_lang_Thread::get_thread_status(threadObj);
_is_ext_suspended = thread->is_being_ext_suspended();
_is_in_native = (thread->thread_state() == _thread_in_native);
oop blocker_object = NULL;
oop blocker_object_owner = NULL;
if (_thread_status == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER ||
_thread_status == java_lang_Thread::IN_OBJECT_WAIT ||
_thread_status == java_lang_Thread::IN_OBJECT_WAIT_TIMED) {
@ -901,7 +881,7 @@ void ThreadSnapshot::initialize(ThreadsList * t_list, JavaThread* thread) {
// monitor no longer exists; thread is not blocked
_thread_status = java_lang_Thread::RUNNABLE;
} else {
_blocker_object = obj();
blocker_object = obj();
JavaThread* owner = ObjectSynchronizer::get_lock_owner(t_list, obj);
if ((owner == NULL && _thread_status == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER)
|| (owner != NULL && owner->is_attaching_via_jni())) {
@ -912,23 +892,37 @@ void ThreadSnapshot::initialize(ThreadsList * t_list, JavaThread* thread) {
// is not completely initialized. For example thread name and id
// and may not be set, so hide the attaching thread.
_thread_status = java_lang_Thread::RUNNABLE;
_blocker_object = NULL;
blocker_object = NULL;
} else if (owner != NULL) {
_blocker_object_owner = owner->threadObj();
blocker_object_owner = owner->threadObj();
}
}
}
// Support for JSR-166 locks
if (_thread_status == java_lang_Thread::PARKED || _thread_status == java_lang_Thread::PARKED_TIMED) {
_blocker_object = thread->current_park_blocker();
if (_blocker_object != NULL && _blocker_object->is_a(SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass())) {
_blocker_object_owner = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(_blocker_object);
blocker_object = thread->current_park_blocker();
if (blocker_object != NULL && blocker_object->is_a(SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass())) {
blocker_object_owner = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(blocker_object);
}
}
if (blocker_object != NULL) {
_blocker_object = OopHandle(Universe::vm_global(), blocker_object);
}
if (blocker_object_owner != NULL) {
_blocker_object_owner = OopHandle(Universe::vm_global(), blocker_object_owner);
}
}
oop ThreadSnapshot::blocker_object() const { return _blocker_object.resolve(); }
oop ThreadSnapshot::blocker_object_owner() const { return _blocker_object_owner.resolve(); }
ThreadSnapshot::~ThreadSnapshot() {
_blocker_object.release(Universe::vm_global());
_blocker_object_owner.release(Universe::vm_global());
_threadObj.release(Universe::vm_global());
delete _stack_trace;
delete _concurrent_locks;
}
@ -939,18 +933,6 @@ void ThreadSnapshot::dump_stack_at_safepoint(int max_depth, bool with_locked_mon
}
void ThreadSnapshot::oops_do(OopClosure* f) {
f->do_oop(&_threadObj);
f->do_oop(&_blocker_object);
f->do_oop(&_blocker_object_owner);
if (_stack_trace != NULL) {
_stack_trace->oops_do(f);
}
if (_concurrent_locks != NULL) {
_concurrent_locks->oops_do(f);
}
}
void ThreadSnapshot::metadata_do(void f(Metadata*)) {
if (_stack_trace != NULL) {
_stack_trace->metadata_do(f);