On Wed, 29 Nov 2023 20:51:02 GMT, Chris Plummer <cjplum...@openjdk.org> wrote:
>> The change impelements dumping of unmounted virtual threads data (stack >> traces and stack references). >> Unmounted vthreads can be detected only by iterating over the heap, but >> hprof stack trace records (HPROF_FRAME/HPROF_TRACE) should be written before >> HPROF_HEAP_DUMP/HPROF_HEAP_DUMP_SEGMENT. >> HeapDumper supports segment dump (parallel dump to separate files with >> subsequent file merge outside of safepoint), the fix switches HeapDumper to >> always use segment dump: 1st segment contains only non-heap data, other >> segments are used for dumping heap objects. For serial dumping >> single-threaded dumping is performed, but 2 segments are created anyway. >> When HeapObjectDumper detects unmounted virtual thread, it writes >> HPROF_FRAME/HPROF_TRACE records to the 1st segment ("global writer"), and >> writes thread object (HPROF_GC_ROOT_JAVA_FRAME) and stack references >> (HPROF_GC_ROOT_JAVA_FRAME/HPROF_GC_ROOT_JNI_LOCAL) to the HeapObjectDumper >> segment. >> As parallel dumpers may write HPROF_FRAME/HPROF_TRACE concurrently and >> VMDumper needs to write non-heap data before heap object dumpers can write >> virtual threads data, writing to global writer is protected with >> DumperController::_global_writer_lock. >> >> Testing: run tests which perform heap dump (in different scenarios): >> - test/hotspot/jtreg/serviceability >> - test/hotspot/jtreg/runtime/ErrorHandling >> - test/hotspot/jtreg/gc/epsilon >> - test/jdk/sun/tools/jhsdb > > I think you are dumping all virtual threads found in the heap, even if they > are unreachable. Although this would be true for platform threads also, there > is a high likelihood of a lot of unreachable virtual threads in the heap, but > not so much for platform threads. > > Also, have you tested scalability? Not just a large number of live virtual > threads (like a million), but also combined with a large number of > unreachable virtual threads. @plummercj said: > I think you are dumping all virtual threads found in the heap, even if they > are unreachable. There is a check for virtual thread liveness which has to be good enough in general: 1617 static bool should_dump_vthread(oop vt) { 1618 return java_lang_VirtualThread::state(vt) != java_lang_VirtualThread::NEW 1619 && java_lang_VirtualThread::state(vt) != java_lang_VirtualThread::TERMINATED; 1620 } . . . 1919 if (java_lang_VirtualThread::is_instance(o) && ThreadDumper::should_dump_vthread(o)) { 1920 _vthread_dumper->dump_vthread(o, writer()); 1921 } ------------- PR Comment: https://git.openjdk.org/jdk/pull/16665#issuecomment-1832794361