RFR: 8299426: Heap dump does not contain virtual Thread stack references

[Chris Plummer]

On Wed, 29 Nov 2023 20:29:40 GMT, Chris Plummer <cjplummer at 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
>
> src/hotspot/share/services/heapDumper.cpp line 2026:
> 
>> 2024:     size_t buf_size = strlen(base_path)
>> 2025:                     + 2                 // ".p"
>> 2026:                     + 1 + (seq / 10)    // number
> 
> Is this suppose to be the number of characters the sequence number will take up in the path? If so, that's not the correct calculation. For example, 35 ends up as 1 + 3 == 4, but it should be 2.

I think the easiest solution is probably just coming up with some reasonable max sequence number and then just assuming that you will need enough chars for it. But if you want to actually compute it, there are a few solutions, including a simple div by 10 loop.

-------------

PR Review Comment: https://git.openjdk.org/jdk/pull/16665#discussion_r1409832990