[OPENJDK-559] Set MaxRAMPercentage=80 by default

Re-write the handling of JAVA_MAX_MEM_RATIO to set -XX:MaxRAMPercentage,
rather than try to set -Xmx and do calculations based on cgroups memory
limits (leave that up to the JVM)

Re-write JAVA_INITIAL_MEM_RATIO similarly. Do not specify a default
value for JAVA_INITIAL_MEM_RATIO: only handle it if the user sets it.
Since this is just a thin wrapper around setting
-XX:InitialRAMPercentage directly, the user can achieve this directly
with JAVA_OPTS. Mark this as deprecated, to be removed in a future
release.

Re-write the handling of JAVA_MAX_MEM_RATIO. Do not set a default
value. If the user specifies a value, map it directly to -Xms. As
with JAVA_INITIAL_MEM_RATIO, this can be achieved directly using
JAVA_OPTS, so mark this as deprecated for removal in a future
release.

If JAVA_MAX_INITIAL_MEM (-Xms) is set, then -XX:InitialRAMPercentage
would be ignored, so do not set it.

We are now no longer using any value derived from interpreting
cgroups v1 files, so remove the container-limits script entirely
and all references to CONTAINER_MAX_MEMORY or CONTAINER_CORE_LIMIT.

Add tests for the default and configured values.

Signed-off-by: Jonathan Dowland <[email protected]>

Author: jmtd

modules/jvm/api/module.yaml

@@ -14,13 +14,22 @@ envs:
   description: User specified Java options to be appended to generated options in JAVA_OPTS.
   example: "-Dsome.property=foo"
 - name: JAVA_MAX_MEM_RATIO
-  description: Is used when no `-Xmx` option is given in **JAVA_OPTS**. This is used to calculate a default maximal heap memory based on a containers restriction. If used in a container without any memory constraints for the container then this option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio of the container available memory as set here. The default is `50` which means 50% of the available memory is used as an upper boundary. You can skip this mechanism by setting this value to `0` in which case no `-Xmx` option is added.
+  description:  Specify the maximum heap memory. Corresponds to the JVM argument `-XX:MaxRAMPercentage`. The default is `80.0` which means 80% of the available memory. You can disable this mechanism by setting the value to `0`.
+  example: "90.0"
 - name: JAVA_INITIAL_MEM_RATIO
-  description: Is used when no `-Xms` option is given in **JAVA_OPTS**. This is used to calculate a default initial heap memory based on the maximum heap memory. If used in a container without any memory constraints for the container then this option has no effect. If there is a memory constraint then `-Xms` is set to a ratio of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx` is used as the initial heap size. You can skip this mechanism by setting this value to `0` in which case no `-Xms` option is added.
-  example: "25"
+  description:
+    Specify the initial heap memory. Corresponds to the JVM argument
+    `-XX:InitialRAMPercentage`. By default this is not specified.
+    **This is deprecated and will be removed in a future release. Users should
+    specify `-XX:InitialRAMPercentage` directly in JAVA_OPTS instead.**
+  example: "25.0"
 - name: JAVA_MAX_INITIAL_MEM
-  description: Is used when no `-Xms` option is given in **JAVA_OPTS**. This is used to calculate the maximum value of the initial heap memory. If used in a container without any memory constraints for the container then this option has no effect. If there is a memory constraint then `-Xms` is limited to the value set here. The default is 4096MB which means the calculated value of `-Xms` never will be greater than 4096MB. The value of this variable is expressed in MB.
-  example: "4096"
+  description:
+    This value is passed through to the `-Xms` Java option, setting both the
+    minimum and initial heap size. By default this is unset.
+    **This is deprecated and will be removed in a future release. Users should
+    specify `-Xms` directly in JAVA_OPTS instead.**
+  example: "4096m"
 - name: JAVA_DIAGNOSTICS
   description: Set this to get some diagnostics information to standard output when things are happening. **Note:** This option, if set to true, will set `-XX:+UnlockDiagnosticVMOptions`. **Disabled by default.**
   example: "true"
@@ -30,9 +39,6 @@ envs:
 - name: JAVA_DEBUG_PORT
   description: Port used for remote debugging. Defaults to *5005*.
   example: "8787"
-- name: CONTAINER_MAX_MEMORY
-  description: Memory limit given to the container.
-  example: "1024"
 - name: GC_MIN_HEAP_FREE_RATIO
   description: Minimum percentage of heap free after GC to avoid expansion.
   example: "20"

modules/jvm/bash/artifacts/opt/jboss/container/java/jvm/container-limits

@@ -5,33 +5,6 @@
 #
 # Usage: JAVA_OPTS="$(java-default-options.sh)"
 
-# Env Vars respected:
-
-# JAVA_OPTIONS: Checked for already set options.  Deprecated, use JAVA_OPTS.
-# JAVA_OPTS: Checked for already set options
-# JAVA_INITIAL_MEM_RATIO: Ratio of maximum memory to use for initial heap size
-#                         (i.e. -Xms).  Defaults to 25 (i.e -Xms=-Xmx/4).
-# JAVA_MAX_INITIAL_MEM: The maximum value of the initial heap size, defaults to 4G.
-# JAVA_MAX_MEM_RATIO: Ratio use to calculate a default maximum Memory, in percent.
-#                     E.g. the default value "50" implies that 50% of the Memory
-#                     given to the container is used as the maximum heap memory with
-#                     '-Xmx'. It is a heuristic and should be better backed up with real
-#                     experiments and measurements.
-#                     For a good overviews what tuning options are available -->
-#                             https://youtu.be/Vt4G-pHXfs4
-#                             https://www.youtube.com/watch?v=w1rZOY5gbvk
-#                             https://vimeo.com/album/4133413/video/181900266
-# Also note that heap is only a small portion of the memory used by a JVM. There are lot
-# of other memory areas (metadata, thread, code cache, ...) which addes to the overall
-# size. There is no easy solution for this, 50% seems to be are reasonable compromise.
-# However, when your container gets killed because of an OOM, then you should tune
-# the absolute values
-#
-
-__DEFAULT_JAVA_MAX_MEM_RATIO=50
-__DEFAULT_JAVA_INITIAL_MEM_RATIO=25
-__DEFAULT_JAVA_MAX_INITIAL_MEM=4096
-
 # stubs for jvm specific overrides
 jvm_specific_options() {
   :
@@ -46,63 +19,25 @@ if [ -f "${JBOSS_CONTAINER_OPENJDK_JDK_MODULE}/jvm-options" ]; then
   source "${JBOSS_CONTAINER_OPENJDK_JDK_MODULE}/jvm-options"
 fi
 
-initialize_container_limits() {
-  # we can't run without limits
-  source ${JBOSS_CONTAINER_JAVA_JVM_MODULE}/container-limits
-}
-
 # Check for memory options and calculate a sane default if not given
 max_memory() {
-  # Check whether -Xmx is already given in JAVA_OPTIONS. Then we dont
-  # do anything here
-  # XXX: I think this should be removed.  If folks want to hard code max/min,
-  # then they can set the ratios to zero and set the options in JAVA_OPTS_APPEND.
-  if echo "${JAVA_OPTS:-${JAVA_OPTIONS}}" | grep -q -- "-Xmx"; then
-    return
-  fi
-
-  # Check if explicitely disabled
+  # Check if explicitly disabled
   if [ "x$JAVA_MAX_MEM_RATIO" = "x0" ]; then
     return
   fi
-
-  # Check for the 'real memory size' and caluclate mx from a ratio
-  # given (default is 50%)
-  if [ "x$CONTAINER_MAX_MEMORY" != x ]; then
-    local max_mem="${CONTAINER_MAX_MEMORY}"
-    local ratio=${JAVA_MAX_MEM_RATIO:-${__DEFAULT_JAVA_MAX_MEM_RATIO}}
-    local mx=$(echo "${max_mem} ${ratio} 1048576" | awk '{printf "%d\n" , ($1*$2)/(100*$3) + 0.5}')
-    echo "-Xmx${mx}m"
-  fi
+  echo "-XX:MaxRAMPercentage=${JAVA_MAX_MEM_RATIO:-80.0}"
 }
 
 # Check for memory options and calculate a sane default if not given
 initial_memory() {
-  # Check whether -Xms is already given in JAVA_OPTS. Then we dont
-  # do anything here
-  # XXX: I think this should be removed.  If folks want to hard code max/min,
-  # then they can set the ratios to zero and set the options in JAVA_OPTS_APPEND.
-  if echo "${JAVA_OPTS:-${JAVA_OPTIONS}}" | grep -q -- "-Xms"; then
-    return
-  fi
-
-  # Check if explicitly disabled
-  if [ "x$JAVA_INITIAL_MEM_RATIO" = "x0" ]; then
-    return
-  fi
-
-  # Check for the 'real memory size' and calculate ms from a ratio
-  # given (default is 25%)
-  if [ "x$CONTAINER_MAX_MEMORY" != x ]; then
-    local max_mem="${CONTAINER_MAX_MEMORY}"
-    local max_ratio=${JAVA_MAX_MEM_RATIO:-${__DEFAULT_JAVA_MAX_MEM_RATIO}}
-    local initial_ratio=${JAVA_INITIAL_MEM_RATIO:-${__DEFAULT_JAVA_INITIAL_MEM_RATIO}}
-    local ms=$(echo "${max_mem} ${max_ratio} ${initial_ratio} 1048576" | awk '{printf "%d\n" , ($1*(($2*$3)/10000))/$4 + 0.5}')
-    local max_initial_memory=${JAVA_MAX_INITIAL_MEM:-${__DEFAULT_JAVA_MAX_INITIAL_MEM}}
-    if [ "${ms}" -lt "${max_initial_memory}" ] ; then
-      echo "-Xms${ms}m"
-    else
-      echo "-Xms${max_initial_memory}m"
+  # JAVA_MAX_INITIAL_MEM is deprecated and will be removed in a future release
+  if [ -n "$JAVA_MAX_INITIAL_MEM" ]; then
+    echo "-Xms$JAVA_MAX_INITIAL_MEM"
+  else
+    # there's no point setting this if we are passing -Xms, since -Xms
+    # overrides this
+    if [ -n "$JAVA_INITIAL_MEM_RATIO" ]; then
+      echo "-XX:InitialRAMPercentage=${JAVA_INITIAL_MEM_RATIO}"
     fi
   fi
 }
@@ -157,7 +92,5 @@ error_handling() {
   echo "-XX:+ExitOnOutOfMemoryError"
 }
 
-initialize_container_limits > /dev/null
-
 ## Echo options, trimming trailing and multiple spaces
 echo "$(initial_memory) $(max_memory) $(gc_config) $(diagnostics) $(error_handling)" | awk '$1=$1'

modules/jvm/bash/artifacts/opt/jboss/container/java/jvm/java-default-options

@@ -92,11 +92,6 @@ load_env() {
   fi
   export JAVA_APP_DIR
 
-  # Read in container limits and export the as environment variables
-  if [ -f "${JBOSS_CONTAINER_JAVA_JVM_MODULE}/container-limits" ]; then
-    source "${JBOSS_CONTAINER_JAVA_JVM_MODULE}/container-limits"
-  fi
-
   # JAVA_LIB_DIR defaults to JAVA_APP_DIR
   export JAVA_LIB_DIR="${JAVA_LIB_DIR:-${JAVA_APP_DIR}}"
   if [ -z "${JAVA_MAIN_CLASS}" ] && [ -z "${JAVA_APP_JAR}" ]; then

modules/run/artifacts/opt/jboss/container/java/run/run-java.sh

@@ -0,0 +1,33 @@
+@openjdk
+@redhat-openjdk-18
+@ubi8
+Feature: OPENJDK-559 JVM Memory tests
+
+  Scenario: Check default JVM max heap configuration
+    Given container is started as uid 1000
+    Then container log should contain -XX:MaxRAMPercentage=80.0
+
+  Scenario: Check configured JVM max heap configuration
+    Given container is started with env
+    | variable           | value  |
+    | JAVA_MAX_MEM_RATIO | 90.0   |
+    Then container log should contain -XX:MaxRAMPercentage=90.0
+
+  Scenario: Check default JVM initial heap configuration is unspecified
+    Given container is started as uid 1000
+    Then container log should not contain -XX:InitialRAMPercentage
+    And  container log should not contain -Xms
+
+  Scenario: Check configured JVM max heap configuration
+    Given container is started with env
+    | variable               | value  |
+    | JAVA_INITIAL_MEM_RATIO | 25.0   |
+    Then container log should contain -XX:InitialRAMPercentage=25.0
+
+  Scenario: check JAVA_MAX_INITIAL_MEM overrides JAVA_INITIAL_MEM_RATIO
+    Given container is started with env
+    | variable               | value  |
+    | JAVA_INITIAL_MEM_RATIO | 25.0   |
+    | JAVA_MAX_INITIAL_MEM   | 4096m  |
+    Then container log should contain -Xms4096m
+    And  container log should not contain -XX:InitialRAMPercentage=25.0