27 #include "classfile/vmClasses.hpp"
28 #include "classfile/vmSymbols.hpp"
29 #include "gc/shared/oopStorageSet.hpp"
30 #include "memory/heapInspection.hpp"
31 #include "memory/oopFactory.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "memory/universe.hpp"
34 #include "nmt/memTag.hpp"
35 #include "oops/instanceKlass.hpp"
36 #include "oops/klass.inline.hpp"
37 #include "oops/method.inline.hpp"
38 #include "oops/objArrayKlass.hpp"
39 #include "oops/objArrayOop.inline.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "oops/oopHandle.inline.hpp"
42 #include "prims/jvmtiRawMonitor.hpp"
43 #include "prims/jvmtiThreadState.hpp"
44 #include "runtime/atomicAccess.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/init.hpp"
47 #include "runtime/javaCalls.hpp"
48 #include "runtime/javaThread.inline.hpp"
49 #include "runtime/jniHandles.inline.hpp"
50 #include "runtime/objectMonitor.inline.hpp"
51 #include "runtime/synchronizer.hpp"
52 #include "runtime/thread.inline.hpp"
53 #include "runtime/threads.hpp"
54 #include "runtime/threadSMR.inline.hpp"
55 #include "runtime/vframe.inline.hpp"
56 #include "runtime/vmOperations.hpp"
57 #include "runtime/vmThread.hpp"
58 #include "services/threadService.hpp"
59
60 // TODO: we need to define a naming convention for perf counters
61 // to distinguish counters for:
62 // - standard JSR174 use
63 // - Hotspot extension (public and committed)
64 // - Hotspot extension (private/internal and uncommitted)
65
66 // Default is disabled.
67 bool ThreadService::_thread_monitoring_contention_enabled = false;
1105 continue;
1106 }
1107
1108 // skip jni threads in the process of attaching
1109 if (!include_jni_attaching_threads && jt->is_attaching_via_jni()) {
1110 continue;
1111 }
1112
1113 // skip instances of BoundVirtualThread
1114 if (!include_bound_virtual_threads && jt->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) {
1115 continue;
1116 }
1117
1118 instanceHandle h(cur_thread, (instanceOop) jt->threadObj());
1119 _threads_array->append(h);
1120 }
1121 }
1122
1123
1124 // jdk.internal.vm.ThreadSnapshot support
1125 #if INCLUDE_JVMTI
1126
1127 class GetThreadSnapshotHandshakeClosure: public HandshakeClosure {
1128 private:
1129 static OopStorage* oop_storage() {
1130 assert(_thread_service_storage != nullptr, "sanity");
1131 return _thread_service_storage;
1132 }
1133
1134 public:
1135 struct OwnedLock {
1136 // should be synced with ordinals of jdk.internal.vm.ThreadSnapshot.OwnedLockType enum
1137 enum Type {
1138 NOTHING = -1,
1139 LOCKED = 0,
1140 ELIMINATED = 1,
1141 };
1142
1143 int _frame_depth;
1144 Type _type;
1145 // synchronization object (when type == LOCKED) or its klass (type == ELIMINATED)
1156 PARK_BLOCKER = 0,
1157 WAITING_TO_LOCK = 1,
1158 WAITING_ON = 2,
1159 };
1160
1161 Type _type;
1162 // park blocker or an object the thread waiting on/trying to lock
1163 OopHandle _obj;
1164 // thread that owns park blocker object when park blocker is AbstractOwnableSynchronizer
1165 OopHandle _owner;
1166
1167 Blocker(Type type, OopHandle obj): _type(type), _obj(obj), _owner() {}
1168 Blocker(): _type(NOTHING), _obj(), _owner() {}
1169
1170 bool is_empty() const {
1171 return _type == NOTHING;
1172 }
1173 };
1174
1175 Handle _thread_h;
1176 JavaThread* _java_thread;
1177 int _frame_count; // length of _methods and _bcis arrays
1178 GrowableArray<Method*>* _methods;
1179 GrowableArray<int>* _bcis;
1180 JavaThreadStatus _thread_status;
1181 OopHandle _thread_name;
1182 OopHandle _carrier_thread;
1183 GrowableArray<OwnedLock>* _locks;
1184 Blocker _blocker;
1185
1186 GetThreadSnapshotHandshakeClosure(Handle thread_h):
1187 HandshakeClosure("GetThreadSnapshotHandshakeClosure"),
1188 _thread_h(thread_h), _java_thread(nullptr),
1189 _frame_count(0), _methods(nullptr), _bcis(nullptr),
1190 _thread_status(), _thread_name(nullptr),
1191 _locks(nullptr), _blocker() {
1192 }
1193 virtual ~GetThreadSnapshotHandshakeClosure() {
1194 delete _methods;
1195 delete _bcis;
1196 _thread_name.release(oop_storage());
1197 if (_locks != nullptr) {
1198 for (int i = 0; i < _locks->length(); i++) {
1199 _locks->at(i)._obj.release(oop_storage());
1200 }
1201 delete _locks;
1202 }
1203 _blocker._obj.release(oop_storage());
1204 _blocker._owner.release(oop_storage());
1205 }
1206
1207 private:
1208 void detect_locks(javaVFrame* jvf, int depth) {
1310 oop ownerObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(park_blocker);
1311 if (ownerObj != nullptr) {
1312 _blocker._owner = OopHandle(oop_storage(), ownerObj);
1313 }
1314 }
1315 }
1316
1317 ResourceMark rm(current);
1318 HandleMark hm(current);
1319
1320 const int max_depth = MaxJavaStackTraceDepth;
1321 const bool skip_hidden = !ShowHiddenFrames;
1322
1323 // Pick minimum length that will cover most cases
1324 int init_length = 64;
1325 _methods = new (mtInternal) GrowableArray<Method*>(init_length, mtInternal);
1326 _bcis = new (mtInternal) GrowableArray<int>(init_length, mtInternal);
1327 _locks = new (mtInternal) GrowableArray<OwnedLock>(init_length, mtInternal);
1328 int total_count = 0;
1329
1330 vframeStream vfst(_java_thread != nullptr
1331 ? vframeStream(_java_thread, false, true, vthread_carrier)
1332 : vframeStream(java_lang_VirtualThread::continuation(_thread_h())));
1333
1334 for (;
1335 !vfst.at_end() && (max_depth == 0 || max_depth != total_count);
1336 vfst.next()) {
1337
1338 detect_locks(vfst.asJavaVFrame(), total_count);
1339
1340 if (skip_hidden && (vfst.method()->is_hidden() ||
1341 vfst.method()->is_continuation_enter_intrinsic())) {
1342 continue;
1343 }
1344 _methods->push(vfst.method());
1345 _bcis->push(vfst.bci());
1346 total_count++;
1347 }
1348
1349 _frame_count = total_count;
1350 }
1351 };
1352
1353 class jdk_internal_vm_ThreadLock: AllStatic {
1354 static bool _inited;
1355 static int _depth_offset;
1356 static int _typeOrdinal_offset;
1357 static int _obj_offset;
1358
1434 static void set_locks(oop snapshot, oop locks) {
1435 snapshot->obj_field_put(_locks_offset, locks);
1436 }
1437 static void set_blocker(oop snapshot, int type_ordinal, oop lock, oop owner) {
1438 snapshot->int_field_put(_blockerTypeOrdinal_offset, type_ordinal);
1439 snapshot->obj_field_put(_blockerObject_offset, lock);
1440 snapshot->obj_field_put(_parkBlockerOwner_offset, owner);
1441 }
1442 };
1443
1444 bool jdk_internal_vm_ThreadSnapshot::_inited = false;
1445 int jdk_internal_vm_ThreadSnapshot::_name_offset;
1446 int jdk_internal_vm_ThreadSnapshot::_threadStatus_offset;
1447 int jdk_internal_vm_ThreadSnapshot::_carrierThread_offset;
1448 int jdk_internal_vm_ThreadSnapshot::_stackTrace_offset;
1449 int jdk_internal_vm_ThreadSnapshot::_locks_offset;
1450 int jdk_internal_vm_ThreadSnapshot::_blockerTypeOrdinal_offset;
1451 int jdk_internal_vm_ThreadSnapshot::_blockerObject_offset;
1452 int jdk_internal_vm_ThreadSnapshot::_parkBlockerOwner_offset;
1453
1454 oop ThreadSnapshotFactory::get_thread_snapshot(jobject jthread, TRAPS) {
1455 ThreadsListHandle tlh(THREAD);
1456
1457 ResourceMark rm(THREAD);
1458 HandleMark hm(THREAD);
1459
1460 JavaThread* java_thread = nullptr;
1461 oop thread_oop;
1462 bool has_javathread = tlh.cv_internal_thread_to_JavaThread(jthread, &java_thread, &thread_oop);
1463 assert((has_javathread && thread_oop != nullptr) || !has_javathread, "Missing Thread oop");
1464 bool is_virtual = java_lang_VirtualThread::is_instance(thread_oop); // Deals with null
1465
1466 if (!has_javathread && !is_virtual) {
1467 return nullptr; // thread terminated so not of interest
1468 }
1469
1470 // Handshake with target
1471 Handle thread_h(THREAD, thread_oop);
1472 GetThreadSnapshotHandshakeClosure cl(thread_h);
1473 if (java_lang_VirtualThread::is_instance(thread_oop)) {
1474 Handshake::execute(&cl, thread_oop);
1475 } else {
1476 Handshake::execute(&cl, &tlh, java_thread);
1477 }
1478
1479 // StackTrace
1480 InstanceKlass* ste_klass = vmClasses::StackTraceElement_klass();
1481 assert(ste_klass != nullptr, "must be loaded");
1482
1483 objArrayHandle trace = oopFactory::new_objArray_handle(ste_klass, cl._frame_count, CHECK_NULL);
1484
1485 for (int i = 0; i < cl._frame_count; i++) {
1486 methodHandle method(THREAD, cl._methods->at(i));
1487 oop element = java_lang_StackTraceElement::create(method, cl._bcis->at(i), CHECK_NULL);
1488 trace->obj_at_put(i, element);
1489 }
1490
1491 // Locks
1492 Symbol* lock_sym = vmSymbols::jdk_internal_vm_ThreadLock();
1493 Klass* lock_k = SystemDictionary::resolve_or_fail(lock_sym, true, CHECK_NULL);
1494 InstanceKlass* lock_klass = InstanceKlass::cast(lock_k);
1495
1496 objArrayHandle locks;
1497 if (cl._locks != nullptr && cl._locks->length() > 0) {
1498 locks = oopFactory::new_objArray_handle(lock_klass, cl._locks->length(), CHECK_NULL);
1499 for (int n = 0; n < cl._locks->length(); n++) {
1500 GetThreadSnapshotHandshakeClosure::OwnedLock* lock_info = cl._locks->adr_at(n);
1501
1502 Handle lock = jdk_internal_vm_ThreadLock::create(lock_klass,
1503 lock_info->_frame_depth, lock_info->_type, lock_info->_obj, CHECK_NULL);
1504 locks->obj_at_put(n, lock());
1505 }
1506 }
1507
1508 // call static StackTraceElement[] StackTraceElement.of(StackTraceElement[] stackTrace)
1509 // to properly initialize STEs.
1510 JavaValue result(T_OBJECT);
1511 JavaCalls::call_static(&result,
1512 ste_klass,
1513 vmSymbols::java_lang_StackTraceElement_of_name(),
1514 vmSymbols::java_lang_StackTraceElement_of_signature(),
1515 trace,
1516 CHECK_NULL);
1517 // the method return the same trace array
1518
1519 Symbol* snapshot_klass_name = vmSymbols::jdk_internal_vm_ThreadSnapshot();
1520 Klass* snapshot_klass = SystemDictionary::resolve_or_fail(snapshot_klass_name, true, CHECK_NULL);
1521 if (snapshot_klass->should_be_initialized()) {
1522 snapshot_klass->initialize(CHECK_NULL);
1523 }
1524
1525 Handle snapshot = jdk_internal_vm_ThreadSnapshot::allocate(InstanceKlass::cast(snapshot_klass), CHECK_NULL);
1526 jdk_internal_vm_ThreadSnapshot::set_name(snapshot(), cl._thread_name.resolve());
1527 jdk_internal_vm_ThreadSnapshot::set_thread_status(snapshot(), (int)cl._thread_status);
1528 jdk_internal_vm_ThreadSnapshot::set_carrier_thread(snapshot(), cl._carrier_thread.resolve());
1529 jdk_internal_vm_ThreadSnapshot::set_stack_trace(snapshot(), trace());
1530 jdk_internal_vm_ThreadSnapshot::set_locks(snapshot(), locks());
1531 if (!cl._blocker.is_empty()) {
1532 jdk_internal_vm_ThreadSnapshot::set_blocker(snapshot(),
1533 cl._blocker._type, cl._blocker._obj.resolve(), cl._blocker._owner.resolve());
1534 }
1535 return snapshot();
1536 }
1537
1538 #endif // INCLUDE_JVMTI
|
27 #include "classfile/vmClasses.hpp"
28 #include "classfile/vmSymbols.hpp"
29 #include "gc/shared/oopStorageSet.hpp"
30 #include "memory/heapInspection.hpp"
31 #include "memory/oopFactory.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "memory/universe.hpp"
34 #include "nmt/memTag.hpp"
35 #include "oops/instanceKlass.hpp"
36 #include "oops/klass.inline.hpp"
37 #include "oops/method.inline.hpp"
38 #include "oops/objArrayKlass.hpp"
39 #include "oops/objArrayOop.inline.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "oops/oopHandle.inline.hpp"
42 #include "prims/jvmtiRawMonitor.hpp"
43 #include "prims/jvmtiThreadState.hpp"
44 #include "runtime/atomicAccess.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/init.hpp"
47 #include "runtime/javaThread.inline.hpp"
48 #include "runtime/jniHandles.inline.hpp"
49 #include "runtime/objectMonitor.inline.hpp"
50 #include "runtime/synchronizer.hpp"
51 #include "runtime/thread.inline.hpp"
52 #include "runtime/threads.hpp"
53 #include "runtime/threadSMR.inline.hpp"
54 #include "runtime/vframe.inline.hpp"
55 #include "runtime/vmOperations.hpp"
56 #include "runtime/vmThread.hpp"
57 #include "services/threadService.hpp"
58
59 // TODO: we need to define a naming convention for perf counters
60 // to distinguish counters for:
61 // - standard JSR174 use
62 // - Hotspot extension (public and committed)
63 // - Hotspot extension (private/internal and uncommitted)
64
65 // Default is disabled.
66 bool ThreadService::_thread_monitoring_contention_enabled = false;
1104 continue;
1105 }
1106
1107 // skip jni threads in the process of attaching
1108 if (!include_jni_attaching_threads && jt->is_attaching_via_jni()) {
1109 continue;
1110 }
1111
1112 // skip instances of BoundVirtualThread
1113 if (!include_bound_virtual_threads && jt->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) {
1114 continue;
1115 }
1116
1117 instanceHandle h(cur_thread, (instanceOop) jt->threadObj());
1118 _threads_array->append(h);
1119 }
1120 }
1121
1122
1123 // jdk.internal.vm.ThreadSnapshot support
1124
1125 class GetThreadSnapshotHandshakeClosure: public HandshakeClosure {
1126 private:
1127 static OopStorage* oop_storage() {
1128 assert(_thread_service_storage != nullptr, "sanity");
1129 return _thread_service_storage;
1130 }
1131
1132 public:
1133 struct OwnedLock {
1134 // should be synced with ordinals of jdk.internal.vm.ThreadSnapshot.OwnedLockType enum
1135 enum Type {
1136 NOTHING = -1,
1137 LOCKED = 0,
1138 ELIMINATED = 1,
1139 };
1140
1141 int _frame_depth;
1142 Type _type;
1143 // synchronization object (when type == LOCKED) or its klass (type == ELIMINATED)
1154 PARK_BLOCKER = 0,
1155 WAITING_TO_LOCK = 1,
1156 WAITING_ON = 2,
1157 };
1158
1159 Type _type;
1160 // park blocker or an object the thread waiting on/trying to lock
1161 OopHandle _obj;
1162 // thread that owns park blocker object when park blocker is AbstractOwnableSynchronizer
1163 OopHandle _owner;
1164
1165 Blocker(Type type, OopHandle obj): _type(type), _obj(obj), _owner() {}
1166 Blocker(): _type(NOTHING), _obj(), _owner() {}
1167
1168 bool is_empty() const {
1169 return _type == NOTHING;
1170 }
1171 };
1172
1173 Handle _thread_h;
1174 jboolean _include_monitors;
1175 JavaThread* _java_thread;
1176 int _frame_count; // length of _methods and _bcis arrays
1177 GrowableArray<Method*>* _methods;
1178 GrowableArray<int>* _bcis;
1179 JavaThreadStatus _thread_status;
1180 OopHandle _thread_name;
1181 OopHandle _carrier_thread;
1182 GrowableArray<OwnedLock>* _locks;
1183 Blocker _blocker;
1184
1185 GetThreadSnapshotHandshakeClosure(Handle thread_h, jboolean include_monitors):
1186 HandshakeClosure("GetThreadSnapshotHandshakeClosure"),
1187 _thread_h(thread_h), _include_monitors(include_monitors), _java_thread(nullptr),
1188 _frame_count(0), _methods(nullptr), _bcis(nullptr),
1189 _thread_status(), _thread_name(nullptr),
1190 _locks(nullptr), _blocker() {
1191 }
1192 virtual ~GetThreadSnapshotHandshakeClosure() {
1193 delete _methods;
1194 delete _bcis;
1195 _thread_name.release(oop_storage());
1196 if (_locks != nullptr) {
1197 for (int i = 0; i < _locks->length(); i++) {
1198 _locks->at(i)._obj.release(oop_storage());
1199 }
1200 delete _locks;
1201 }
1202 _blocker._obj.release(oop_storage());
1203 _blocker._owner.release(oop_storage());
1204 }
1205
1206 private:
1207 void detect_locks(javaVFrame* jvf, int depth) {
1309 oop ownerObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(park_blocker);
1310 if (ownerObj != nullptr) {
1311 _blocker._owner = OopHandle(oop_storage(), ownerObj);
1312 }
1313 }
1314 }
1315
1316 ResourceMark rm(current);
1317 HandleMark hm(current);
1318
1319 const int max_depth = MaxJavaStackTraceDepth;
1320 const bool skip_hidden = !ShowHiddenFrames;
1321
1322 // Pick minimum length that will cover most cases
1323 int init_length = 64;
1324 _methods = new (mtInternal) GrowableArray<Method*>(init_length, mtInternal);
1325 _bcis = new (mtInternal) GrowableArray<int>(init_length, mtInternal);
1326 _locks = new (mtInternal) GrowableArray<OwnedLock>(init_length, mtInternal);
1327 int total_count = 0;
1328
1329 bool include_monitors = (_include_monitors == JNI_TRUE);
1330 vframeStream vfst(_java_thread != nullptr
1331 ? vframeStream(_java_thread, false, include_monitors, vthread_carrier)
1332 : vframeStream(java_lang_VirtualThread::continuation(_thread_h())));
1333
1334 for (;
1335 !vfst.at_end() && (max_depth == 0 || max_depth != total_count);
1336 vfst.next()) {
1337
1338 if (include_monitors) {
1339 detect_locks(vfst.asJavaVFrame(), total_count);
1340 }
1341
1342 if (skip_hidden && (vfst.method()->is_hidden() ||
1343 vfst.method()->is_continuation_enter_intrinsic())) {
1344 continue;
1345 }
1346 _methods->push(vfst.method());
1347 _bcis->push(vfst.bci());
1348 total_count++;
1349 }
1350
1351 _frame_count = total_count;
1352 }
1353 };
1354
1355 class jdk_internal_vm_ThreadLock: AllStatic {
1356 static bool _inited;
1357 static int _depth_offset;
1358 static int _typeOrdinal_offset;
1359 static int _obj_offset;
1360
1436 static void set_locks(oop snapshot, oop locks) {
1437 snapshot->obj_field_put(_locks_offset, locks);
1438 }
1439 static void set_blocker(oop snapshot, int type_ordinal, oop lock, oop owner) {
1440 snapshot->int_field_put(_blockerTypeOrdinal_offset, type_ordinal);
1441 snapshot->obj_field_put(_blockerObject_offset, lock);
1442 snapshot->obj_field_put(_parkBlockerOwner_offset, owner);
1443 }
1444 };
1445
1446 bool jdk_internal_vm_ThreadSnapshot::_inited = false;
1447 int jdk_internal_vm_ThreadSnapshot::_name_offset;
1448 int jdk_internal_vm_ThreadSnapshot::_threadStatus_offset;
1449 int jdk_internal_vm_ThreadSnapshot::_carrierThread_offset;
1450 int jdk_internal_vm_ThreadSnapshot::_stackTrace_offset;
1451 int jdk_internal_vm_ThreadSnapshot::_locks_offset;
1452 int jdk_internal_vm_ThreadSnapshot::_blockerTypeOrdinal_offset;
1453 int jdk_internal_vm_ThreadSnapshot::_blockerObject_offset;
1454 int jdk_internal_vm_ThreadSnapshot::_parkBlockerOwner_offset;
1455
1456 oop ThreadSnapshotFactory::get_thread_snapshot(jobject jthread, jboolean include_monitors, TRAPS) {
1457 ThreadsListHandle tlh(THREAD);
1458
1459 ResourceMark rm(THREAD);
1460 HandleMark hm(THREAD);
1461
1462 JavaThread* java_thread = nullptr;
1463 oop thread_oop;
1464 bool has_javathread = tlh.cv_internal_thread_to_JavaThread(jthread, &java_thread, &thread_oop);
1465 assert((has_javathread && thread_oop != nullptr) || !has_javathread, "Missing Thread oop");
1466 bool is_virtual = java_lang_VirtualThread::is_instance(thread_oop); // Deals with null
1467
1468 if (!has_javathread && !is_virtual) {
1469 return nullptr; // thread terminated so not of interest
1470 }
1471
1472 // Handshake with target
1473 Handle thread_h(THREAD, thread_oop);
1474 GetThreadSnapshotHandshakeClosure cl(thread_h, include_monitors);
1475 if (java_lang_VirtualThread::is_instance(thread_oop)) {
1476 Handshake::execute(&cl, thread_oop);
1477 } else {
1478 Handshake::execute(&cl, &tlh, java_thread);
1479 }
1480
1481 // thread not alive
1482 if (cl._thread_status == JavaThreadStatus::NEW || cl._thread_status == JavaThreadStatus::TERMINATED) {
1483 return nullptr;
1484 }
1485
1486 // StackTrace
1487 InstanceKlass* ste_klass = vmClasses::StackTraceElement_klass();
1488 assert(ste_klass != nullptr, "must be loaded");
1489
1490 objArrayHandle trace = oopFactory::new_objArray_handle(ste_klass, cl._frame_count, CHECK_NULL);
1491
1492 for (int i = 0; i < cl._frame_count; i++) {
1493 methodHandle method(THREAD, cl._methods->at(i));
1494 oop element = java_lang_StackTraceElement::create(method, cl._bcis->at(i), CHECK_NULL);
1495 trace->obj_at_put(i, element);
1496 }
1497
1498 // Locks
1499 Symbol* lock_sym = vmSymbols::jdk_internal_vm_ThreadLock();
1500 Klass* lock_k = SystemDictionary::resolve_or_fail(lock_sym, true, CHECK_NULL);
1501 InstanceKlass* lock_klass = InstanceKlass::cast(lock_k);
1502
1503 objArrayHandle locks;
1504 if (cl._locks != nullptr && cl._locks->length() > 0) {
1505 locks = oopFactory::new_objArray_handle(lock_klass, cl._locks->length(), CHECK_NULL);
1506 for (int n = 0; n < cl._locks->length(); n++) {
1507 GetThreadSnapshotHandshakeClosure::OwnedLock* lock_info = cl._locks->adr_at(n);
1508
1509 Handle lock = jdk_internal_vm_ThreadLock::create(lock_klass,
1510 lock_info->_frame_depth, lock_info->_type, lock_info->_obj, CHECK_NULL);
1511 locks->obj_at_put(n, lock());
1512 }
1513 }
1514
1515 Symbol* snapshot_klass_name = vmSymbols::jdk_internal_vm_ThreadSnapshot();
1516 Klass* snapshot_klass = SystemDictionary::resolve_or_fail(snapshot_klass_name, true, CHECK_NULL);
1517 if (snapshot_klass->should_be_initialized()) {
1518 snapshot_klass->initialize(CHECK_NULL);
1519 }
1520
1521 Handle snapshot = jdk_internal_vm_ThreadSnapshot::allocate(InstanceKlass::cast(snapshot_klass), CHECK_NULL);
1522 jdk_internal_vm_ThreadSnapshot::set_name(snapshot(), cl._thread_name.resolve());
1523 jdk_internal_vm_ThreadSnapshot::set_thread_status(snapshot(), (int)cl._thread_status);
1524 jdk_internal_vm_ThreadSnapshot::set_carrier_thread(snapshot(), cl._carrier_thread.resolve());
1525 jdk_internal_vm_ThreadSnapshot::set_stack_trace(snapshot(), trace());
1526 jdk_internal_vm_ThreadSnapshot::set_locks(snapshot(), locks());
1527 if (!cl._blocker.is_empty()) {
1528 jdk_internal_vm_ThreadSnapshot::set_blocker(snapshot(),
1529 cl._blocker._type, cl._blocker._obj.resolve(), cl._blocker._owner.resolve());
1530 }
1531 return snapshot();
1532 }
|