Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-8158045

Improve large object handling during evacuation

    Details

    • Type: Enhancement
    • Status: Open
    • Priority: P3
    • Resolution: Unresolved
    • Affects Version/s: 9
    • Fix Version/s: tbd
    • Component/s: hotspot
    • Subcomponent:
      gc

      Description

      On large heaps we use 32M regions, which means that the maximum object size that is not directly allocated in old is 16M.

      This is already quite large, so that if there are multiple of these objects to copy and scan, if there are many threads, we effectively serialize GC.

      Further, the current splitting of scanning of large objects is in itself also a serialization: we only create a head and a single tail object, where the former is immediately processed by the current thread, and the latter pushed on the object stack.

      There are a few problems with this mechanism:
      - the amount of achievable parallelism is very small, as we only generate one tail object. I.e. only one other thread can steal, and then do the same.
      - the split threshold is too small, i.e. we split at ~100 words into parts of 50 words or so. However it may happen that because of this, the original thread will immediately claim the tail (particular if it is a value type array), so effectively not parallelizing at all.

      We have seen serious serialization going on (termination time in the seconds per threads) on large young gens (many GBs) on systems with many threads.

        Attachments

          Activity

            People

            • Assignee:
              Unassigned
              Reporter:
              tschatzl Thomas Schatzl
            • Votes:
              0 Vote for this issue
              Watchers:
              1 Start watching this issue

              Dates

              • Created:
                Updated: