RFR: 8236073: G1: Use SoftMaxHeapSize to guide GC heuristics
thomas.schatzl at oracle.com
Tue Feb 18 20:52:08 UTC 2020
dug through the changes a bit, took longer and only managed to do
cursory testing as there were a few issues.
That (very) cursory testing showed that memory consumption on one
specjvm2008 out-of-box application is as baselined, but currently
running the full set.
The change I used is available at
http://cr.openjdk.java.net/~tschatzl/8236073/webrev.2/, I will step
through what changed below.
- not really a bug and pre-existing, but I changed the various
resize_heap_* to always include the exact GC pause because particularly
for the "after_concurrent_mark" suffix it is not clear what this means.
I.e. in the Remark or Cleanup pauses, or at the real end of concurrent
cycle (still concurrent)?
This has not been done consistently yet.
- I think there has been a copy&paste error in
G1CollectedHeap::resize_heap_if_necessary, the two calculations to
determine the min and max desired capacity were equal. I.e.
1178 size_t minimum_desired_capacity =
1179 size_t maximum_desired_capacity =
Note the duplicate use of MinHeapFreeRatio. Fixed in above webrev.
- CollectorState contains flags that basically indicate they type of GC,
which should be set at the start of gc and updated at the end of gc. The
new finish_of_mixed_gc does not fit here as it is basically a flag
indicating that we need to do the resizing.
The previous implementation also lets the first young-only gc after the
last mixed gc do the resizing which is probably not as intended.
By adding an additional policy()->next_gc_should_be_mixed() call instead
of the state check (and removing this pause state/type completely) fixes
this (I think ;)).
- the suggested change removes the expansion during Cleanup for the
reasons stated earlier. This removes the need for some code in the
G1HeapSizingPolicy where originally _minimum_desired_bytes_after_last_cm
had been stored. It's better to move this to G1Policy (and pre-existing,
G1Policy should be the owner of G1HeapSizingPolicy which I did not fix
in this change)
- (the suggested change does not add the shrinking at remark discussed
earlier; I still think it would be nice and maybe fix that failing
- there should be more gc+heap+ergo logging of calculated
targets/desired sizes in the new methods in G1HeapSizingPolicy,
otherwise the decisions are very hard to follow after the fact.
- I believe there is an underestimation of the desired bytes after
concurrent mark with adaptive IHOP enabled in the current code. If you
look at the method G1Policy::desired_bytes_after_concurrent_mark(), the
two terms returned by that method do not seem equal. I.e.
G1AdaptiveIHOP::predict_unrestrained_buffer_size() does not contain the
used bytes, the reserve and other parts used for the static IHOP (i.e.
minimum_desired_buffer_size == 0).
At most, G1AdaptiveIHOP::predict_unrestrained_buffer_size() covers the
young gen part of the latter. Some better name for this should be found
As mentioned, currently running more tests until tomorrow (even with
above known issues) to get some experience/data to look at with the
sizing at mixed gc heuristic.
More information about the hotspot-gc-dev