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

Reply via email to