tillrohrmann commented on a change in pull request #9760: [FLINK-13982][runtime] Implement memory calculation logics URL: https://github.com/apache/flink/pull/9760#discussion_r333995806
########## File path: flink-runtime/src/main/java/org/apache/flink/runtime/clusterframework/TaskExecutorResourceUtils.java ########## @@ -0,0 +1,659 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.flink.runtime.clusterframework; + +import org.apache.flink.configuration.Configuration; +import org.apache.flink.configuration.IllegalConfigurationException; +import org.apache.flink.configuration.MemorySize; +import org.apache.flink.configuration.NettyShuffleEnvironmentOptions; +import org.apache.flink.configuration.TaskManagerOptions; +import org.apache.flink.runtime.util.ConfigurationParserUtils; + +import java.util.HashMap; +import java.util.Map; + +import static org.apache.flink.util.Preconditions.checkArgument; +import static org.apache.flink.util.Preconditions.checkNotNull; + +/** + * Utility class for TaskExecutor memory configurations. + * + * <p>A TaskExecutor's memory consists of the following components. + * <ul> + * <li>Framework Heap Memory</li> + * <li>Task Heap Memory</li> + * <li>Task Off-Heap Memory</li> + * <li>Shuffle Memory</li> + * <li>Managed Memory</li> + * <ul> + * <li>On-Heap Managed Memory</li> + * <li>Off-Heap Managed Memory</li> + * </ul> + * <li>JVM Metaspace</li> + * <li>JVM Overhead</li> + * </ul> + * Among all the components, Framework Heap Memory, Task Heap Memory and On-Heap Managed Memory use on heap memory, + * while the rest use off heap memory. We use Total Process Memory to refer to all the memory components, while Total + * Flink Memory refering to all the components except JVM Metaspace and JVM Overhead. + * + * <p>The relationships of TaskExecutor memory components are shown below. + * <pre> + * ┌ ─ ─ Total Process Memory ─ ─ ┐ + * ┌ ─ ─ Total Flink Memory ─ ─ ┐ + * │ ┌───────────────────────────┐ │ + * ││ Framework Heap Memory ││ ─┐ + * │ └───────────────────────────┘ │ │ + * │┌───────────────────────────┐│ │ + * │ │ Task Heap Memory │ │ ─┤ + * │└───────────────────────────┘│ │ + * │ ┌───────────────────────────┐ │ │ + * ┌─ ││ Task Off-Heap Memory ││ │ + * │ │ └───────────────────────────┘ │ ├─ On-Heap + * │ │┌───────────────────────────┐│ │ + * ├─ │ │ Shuffle Memory │ │ │ + * │ │└───────────────────────────┘│ │ + * │ │ ┌───── Managed Memory ──────┐ │ │ + * │ ││┌─────────────────────────┐││ │ + * │ │ ││ On-Heap Managed Memory ││ │ ─┘ + * │ ││├─────────────────────────┤││ + * Off-Heap ─┼─ │ ││ Off-Heap Managed Memory ││ │ + * │ ││└─────────────────────────┘││ + * │ │ └───────────────────────────┘ │ + * │ └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘ + * │ │┌─────────────────────────────┐│ + * ├─ │ JVM Metaspace │ + * │ │└─────────────────────────────┘│ + * │ ┌─────────────────────────────┐ + * └─ ││ JVM Overhead ││ + * └─────────────────────────────┘ + * └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘ + * </pre> + */ +public class TaskExecutorResourceUtils { + + private TaskExecutorResourceUtils() {} + + // ------------------------------------------------------------------------ + // Generating JVM Parameters + // ------------------------------------------------------------------------ + + public static String generateJvmParametersStr(final TaskExecutorResourceSpec taskExecutorResourceSpec) { + final MemorySize jvmHeapSize = taskExecutorResourceSpec.getFrameworkHeapSize() + .add(taskExecutorResourceSpec.getTaskHeapSize()) + .add(taskExecutorResourceSpec.getOnHeapManagedMemorySize()); + final MemorySize jvmDirectSize = taskExecutorResourceSpec.getTaskOffHeapSize() + .add(taskExecutorResourceSpec.getShuffleMemSize()); + final MemorySize jvmMetaspaceSize = taskExecutorResourceSpec.getJvmMetaspaceSize(); + + return "-Xmx" + jvmHeapSize.getBytes() + + " -Xms" + jvmHeapSize.getBytes() + + " -XX:MaxDirectMemorySize=" + jvmDirectSize.getBytes() + + " -XX:MetaspaceSize=" + jvmMetaspaceSize.getBytes(); + } + + // ------------------------------------------------------------------------ + // Generating Dynamic Config Options + // ------------------------------------------------------------------------ + + public static String generateDynamicConfigsStr(final TaskExecutorResourceSpec taskExecutorResourceSpec) { + final Map<String, String> configs = new HashMap<>(); + configs.put(TaskManagerOptions.FRAMEWORK_HEAP_MEMORY.key(), taskExecutorResourceSpec.getFrameworkHeapSize().getBytes() + "b"); + configs.put(TaskManagerOptions.TASK_HEAP_MEMORY.key(), taskExecutorResourceSpec.getTaskHeapSize().getBytes() + "b"); + configs.put(TaskManagerOptions.TASK_OFF_HEAP_MEMORY.key(), taskExecutorResourceSpec.getTaskOffHeapSize().getBytes() + "b"); + configs.put(TaskManagerOptions.SHUFFLE_MEMORY_MIN.key(), taskExecutorResourceSpec.getShuffleMemSize().getBytes() + "b"); + configs.put(TaskManagerOptions.SHUFFLE_MEMORY_MAX.key(), taskExecutorResourceSpec.getShuffleMemSize().getBytes() + "b"); + configs.put(TaskManagerOptions.MANAGED_MEMORY_SIZE.key(), taskExecutorResourceSpec.getManagedMemorySize().getBytes() + "b"); + configs.put(TaskManagerOptions.MANAGED_MEMORY_OFFHEAP_SIZE.key(), taskExecutorResourceSpec.getOffHeapManagedMemorySize().getBytes() + "b"); + return assembleDynamicConfigsStr(configs); + } + + private static String assembleDynamicConfigsStr(final Map<String, String> configs) { + final StringBuilder sb = new StringBuilder(); + for (Map.Entry<String, String> entry : configs.entrySet()) { + sb.append("-D ").append(entry.getKey()).append("=").append(entry.getValue()).append(" "); + } + return sb.toString(); + } + + // ------------------------------------------------------------------------ + // Memory Configuration Calculations + // ------------------------------------------------------------------------ + + public static TaskExecutorResourceSpec resourceSpecFromConfig(final Configuration config) { + if (isTaskHeapMemorySizeExplicitlyConfigured(config) && isManagedMemorySizeExplicitlyConfigured(config)) { + // both task heap memory and managed memory are configured, use these to derive total flink memory + return deriveResourceSpecWithExplicitTaskAndManagedMemory(config); + } else if (isTotalFlinkMemorySizeExplicitlyConfigured(config)) { + // either of task heap memory and managed memory is not configured, total flink memory is configured, + // derive from total flink memory + return deriveResourceSpecWithTotalFlinkMemory(config); + } else if (isTotalProcessMemorySizeExplicitlyConfigured(config)) { + // total flink memory is not configured, total process memory is configured, + // derive from total process memory + return deriveResourceSpecWithTotalProcessMemory(config); + } else { + throw new IllegalConfigurationException("Either Task Heap Memory size and Managed Memory size, or Total Flink" + + " Memory size, or Total Process Memory size need to be configured explicitly."); + } + } + + private static TaskExecutorResourceSpec deriveResourceSpecWithExplicitTaskAndManagedMemory(final Configuration config) { + // derive flink internal memory from explicitly configure task heap memory size and managed memory size + + final MemorySize taskHeapMemorySize = getTaskHeapMemorySize(config); + final MemorySize managedMemorySize = getManagedMemorySize(config); + + final MemorySize frameworkHeapMemorySize = getFrameworkHeapMemorySize(config); + final MemorySize taskOffHeapMemorySize = getTaskOffHeapMemorySize(config); + + final OnHeapAndOffHeapManagedMemory onHeapAndOffHeapManagedMemory = deriveOnHeapAndOffHeapMemoryFromManagedMemory(config, managedMemorySize); + + final MemorySize shuffleMemorySize; + final MemorySize totalFlinkExcludeShuffleMemorySize = + frameworkHeapMemorySize.add(taskHeapMemorySize).add(taskOffHeapMemorySize).add(managedMemorySize); + + if (isTotalFlinkMemorySizeExplicitlyConfigured(config)) { + // derive shuffle memory from total flink memory, and check against shuffle min/max + final MemorySize totalFlinkMemorySize = getTotalFlinkMemorySize(config); + if (totalFlinkExcludeShuffleMemorySize.getBytes() > totalFlinkMemorySize.getBytes()) { + throw new IllegalConfigurationException( + "Sum of configured Framework Heap Memory (" + frameworkHeapMemorySize.toString() + + "), Task Heap Memory (" + taskHeapMemorySize.toString() + + "), Task Off-Heap Memory (" + taskOffHeapMemorySize.toString() + + ") and Managed Memory (" + managedMemorySize.toString() + + ") exceed configured Total Flink Memory (" + totalFlinkMemorySize.toString() + ")."); + } + shuffleMemorySize = totalFlinkMemorySize.subtract(totalFlinkExcludeShuffleMemorySize); + sanityCheckShuffleMemory(config, shuffleMemorySize, totalFlinkMemorySize); + } else { + // derive shuffle memory from shuffle configs + if (isUsingLegacyShuffleConfigs(config)) { + shuffleMemorySize = getShuffleMemorySizeWithLegacyConfig(config); + } else { + shuffleMemorySize = deriveShuffleMemoryWithInverseFraction(config, totalFlinkExcludeShuffleMemorySize); + } + } + + final FlinkInternalMemory flinkInternalMemory = new FlinkInternalMemory( + frameworkHeapMemorySize, + taskHeapMemorySize, + taskOffHeapMemorySize, + shuffleMemorySize, + onHeapAndOffHeapManagedMemory.onHeap, + onHeapAndOffHeapManagedMemory.offHeap); + sanityCheckTotalFlinkMemory(config, flinkInternalMemory); + + // derive jvm metaspace and overhead + + final JvmMetaspaceAndOverhead jvmMetaspaceAndOverhead = deriveJvmMetaspaceAndOverheadFromTotalFlinkMemory(config, flinkInternalMemory.getTotalFlinkMemorySize()); + sanityCheckTotalProcessMemory(config, flinkInternalMemory.getTotalFlinkMemorySize(), jvmMetaspaceAndOverhead); + + return createTaskExecutorResourceSpec(flinkInternalMemory, jvmMetaspaceAndOverhead); + } + + private static TaskExecutorResourceSpec deriveResourceSpecWithTotalFlinkMemory(final Configuration config) { + // derive flink internal memory from explicitly configured total flink memory + + final MemorySize totalFlinkMemorySize = getTotalFlinkMemorySize(config); + final FlinkInternalMemory flinkInternalMemory = deriveInternalMemoryFromTotalFlinkMemory(config, totalFlinkMemorySize); + + // derive jvm metaspace and overhead + + final JvmMetaspaceAndOverhead jvmMetaspaceAndOverhead = deriveJvmMetaspaceAndOverheadFromTotalFlinkMemory(config, totalFlinkMemorySize); + sanityCheckTotalProcessMemory(config, totalFlinkMemorySize, jvmMetaspaceAndOverhead); + + return createTaskExecutorResourceSpec(flinkInternalMemory, jvmMetaspaceAndOverhead); + } + + private static TaskExecutorResourceSpec deriveResourceSpecWithTotalProcessMemory(final Configuration config) { + // derive total flink memory from explicitly configured total process memory size + + final MemorySize totalProcessMemorySize = getTotalProcessMemorySize(config); + final MemorySize jvmMetaspaceSize = getJvmMetaspaceSize(config); + final MemorySize jvmOverheadSize = deriveJvmOverheadWithFraction(config, totalProcessMemorySize); + final JvmMetaspaceAndOverhead jvmMetaspaceAndOverhead = new JvmMetaspaceAndOverhead(jvmMetaspaceSize, jvmOverheadSize); + + if (jvmMetaspaceAndOverhead.getTotalJvmMetaspaceAndOverheadSize().getBytes() > totalProcessMemorySize.getBytes()) { + throw new IllegalConfigurationException( + "Sum of configured JVM Metaspace (" + jvmMetaspaceAndOverhead.metaspace.toString() + + ") and JVM Overhead (" + jvmMetaspaceAndOverhead.overhead.toString() + + ") exceed configured Total Process Memory (" + totalProcessMemorySize.toString() + ")."); + } + final MemorySize totalFlinkMemorySize = totalProcessMemorySize.subtract(jvmMetaspaceAndOverhead.getTotalJvmMetaspaceAndOverheadSize()); + + // derive flink internal memory + + final FlinkInternalMemory flinkInternalMemory = deriveInternalMemoryFromTotalFlinkMemory(config, totalFlinkMemorySize); + + return createTaskExecutorResourceSpec(flinkInternalMemory, jvmMetaspaceAndOverhead); + } + + private static JvmMetaspaceAndOverhead deriveJvmMetaspaceAndOverheadFromTotalFlinkMemory( + final Configuration config, final MemorySize totalFlinkMemorySize) { + final MemorySize jvmMetaspaceSize = getJvmMetaspaceSize(config); + final MemorySize jvmOverheadSize = deriveJvmOverheadWithInverseFraction(config, + totalFlinkMemorySize.add(jvmMetaspaceSize)); + return new JvmMetaspaceAndOverhead(jvmMetaspaceSize, jvmOverheadSize); + } + + private static FlinkInternalMemory deriveInternalMemoryFromTotalFlinkMemory( + final Configuration config, final MemorySize totalFlinkMemorySize) { + final MemorySize frameworkHeapMemorySize = getFrameworkHeapMemorySize(config); + final MemorySize taskOffHeapMemorySize = getTaskOffHeapMemorySize(config); + + final MemorySize taskHeapMemorySize; + final MemorySize shuffleMemorySize; + final MemorySize managedMemorySize; + + if (isTaskHeapMemorySizeExplicitlyConfigured(config)) { + // task heap memory is configured, + // derive managed memory first, leave the remaining to shuffle memory and check against shuffle min/max + taskHeapMemorySize = getTaskHeapMemorySize(config); + managedMemorySize = deriveManagedMemoryAbsoluteOrWithFraction(config, totalFlinkMemorySize); + final MemorySize totalFlinkExcludeShuffleMemorySize = + frameworkHeapMemorySize.add(taskHeapMemorySize).add(taskOffHeapMemorySize).add(managedMemorySize); + if (totalFlinkExcludeShuffleMemorySize.getBytes() > totalFlinkMemorySize.getBytes()) { + throw new IllegalConfigurationException( + "Sum of configured Framework Heap Memory (" + frameworkHeapMemorySize.toString() + + "), Task Heap Memory (" + taskHeapMemorySize.toString() + + "), Task Off-Heap Memory (" + taskOffHeapMemorySize.toString() + + ") and Managed Memory (" + managedMemorySize.toString() + + ") exceed configured Total Flink Memory (" + totalFlinkMemorySize.toString() + ")."); + } + shuffleMemorySize = totalFlinkMemorySize.subtract(totalFlinkExcludeShuffleMemorySize); + sanityCheckShuffleMemory(config, shuffleMemorySize, totalFlinkMemorySize); + } else { + // task heap memory is not configured + // derive managed memory and shuffle memory, leave the remaining to task heap memory + if (isManagedMemorySizeExplicitlyConfigured(config)) { + managedMemorySize = getManagedMemorySize(config); + } else { + managedMemorySize = deriveManagedMemoryAbsoluteOrWithFraction(config, totalFlinkMemorySize); + } + shuffleMemorySize = deriveShuffleMemoryWithFraction(config, totalFlinkMemorySize); + sanityCheckShuffleMemory(config, shuffleMemorySize, totalFlinkMemorySize); + final MemorySize totalFlinkExcludeTaskHeapMemorySize = + frameworkHeapMemorySize.add(taskOffHeapMemorySize).add(managedMemorySize).add(shuffleMemorySize); + if (totalFlinkExcludeTaskHeapMemorySize.getBytes() > totalFlinkMemorySize.getBytes()) { + throw new IllegalConfigurationException( + "Sum of configured Framework Heap Memory (" + frameworkHeapMemorySize.toString() + + "), Task Off-Heap Memory (" + taskOffHeapMemorySize.toString() + + "), Managed Memory (" + managedMemorySize.toString() + + ") and Shuffle Memory (" + shuffleMemorySize.toString() + + ") exceed configured Total Flink Memory (" + totalFlinkMemorySize.toString() + ")."); + } + taskHeapMemorySize = totalFlinkMemorySize.subtract(totalFlinkExcludeTaskHeapMemorySize); + } + + final OnHeapAndOffHeapManagedMemory onHeapAndOffHeapManagedMemory = deriveOnHeapAndOffHeapMemoryFromManagedMemory(config, managedMemorySize); + final FlinkInternalMemory flinkInternalMemory = new FlinkInternalMemory( + frameworkHeapMemorySize, + taskHeapMemorySize, + taskOffHeapMemorySize, + shuffleMemorySize, + onHeapAndOffHeapManagedMemory.onHeap, + onHeapAndOffHeapManagedMemory.offHeap); + sanityCheckTotalFlinkMemory(config, flinkInternalMemory); + + return flinkInternalMemory; + } + + @SuppressWarnings("deprecation") + private static OnHeapAndOffHeapManagedMemory deriveOnHeapAndOffHeapMemoryFromManagedMemory( + final Configuration config, final MemorySize managedMemorySize) { + + final MemorySize offHeapSize; + + if (isManagedMemoryOffHeapSizeExplicitlyConfigured(config)) { + offHeapSize = getManagedMemoryOffHeapSize(config); + // sanity check + if (offHeapSize.getBytes() > managedMemorySize.getBytes()) { + throw new IllegalConfigurationException("Configured Off-Heap Managed Memory size (" + offHeapSize.toString() + + ") is larger than configured/derived total Managed Memory size (" + managedMemorySize.toString() + ")."); + } + } else { + final double offHeapFraction; + if (isManagedMemoryOffHeapFractionExplicitlyConfigured(config)) { + offHeapFraction = getManagedMemoryOffHeapFraction(config); + } else { + final boolean legacyManagedMemoryOffHeap = config.getBoolean(TaskManagerOptions.MEMORY_OFF_HEAP); + offHeapFraction = legacyManagedMemoryOffHeap ? 1.0 : 0.0; + } + offHeapSize = managedMemorySize.multiply(offHeapFraction); + } + + final MemorySize onHeapSize = managedMemorySize.subtract(offHeapSize); + return new OnHeapAndOffHeapManagedMemory(onHeapSize, offHeapSize); + } + + private static MemorySize deriveManagedMemoryAbsoluteOrWithFraction(final Configuration config, final MemorySize base) { + if (isManagedMemorySizeExplicitlyConfigured(config)) { + return getManagedMemorySize(config); + } else { + return deriveWithFraction(base, getManagedMemoryRangeFraction(config)); + } + } + + private static MemorySize deriveShuffleMemoryWithFraction(final Configuration config, final MemorySize base) { + return deriveWithFraction(base, getShuffleMemoryRangeFraction(config)); + } + + private static MemorySize deriveShuffleMemoryWithInverseFraction(final Configuration config, final MemorySize base) { + return deriveWithInverseFraction(base, getShuffleMemoryRangeFraction(config)); + } + + private static MemorySize deriveJvmOverheadWithFraction(final Configuration config, final MemorySize base) { + return deriveWithFraction(base, getJvmOverheadRangeFraction(config)); + } + + private static MemorySize deriveJvmOverheadWithInverseFraction(final Configuration config, final MemorySize base) { + return deriveWithInverseFraction(base, getJvmOverheadRangeFraction(config)); + } + + private static MemorySize deriveWithFraction(final MemorySize base, final RangeFraction rangeFraction) { + final long relative = (long) (rangeFraction.fraction * base.getBytes()); + return new MemorySize(Math.max(rangeFraction.minSize.getBytes(), Math.min(rangeFraction.maxSize.getBytes(), relative))); + } + + private static MemorySize deriveWithInverseFraction(final MemorySize base, final RangeFraction rangeFraction) { + checkArgument(rangeFraction.fraction < 1); + final long relative = (long) (rangeFraction.fraction / (1 - rangeFraction.fraction) * base.getBytes()); + return new MemorySize(Math.max(rangeFraction.minSize.getBytes(), Math.min(rangeFraction.maxSize.getBytes(), relative))); + } + + private static MemorySize getFrameworkHeapMemorySize(final Configuration config) { + return MemorySize.parse(config.getString(TaskManagerOptions.FRAMEWORK_HEAP_MEMORY)); + } + + private static MemorySize getTaskHeapMemorySize(final Configuration config) { + checkArgument(isTaskHeapMemorySizeExplicitlyConfigured(config)); + return MemorySize.parse(config.getString(TaskManagerOptions.TASK_HEAP_MEMORY)); + } + + private static MemorySize getTaskOffHeapMemorySize(final Configuration config) { + return MemorySize.parse(config.getString(TaskManagerOptions.TASK_OFF_HEAP_MEMORY)); + } + + private static MemorySize getManagedMemorySize(final Configuration config) { + checkArgument(isManagedMemorySizeExplicitlyConfigured(config)); + return MemorySize.parse(config.getString(TaskManagerOptions.MANAGED_MEMORY_SIZE)); + } + + private static RangeFraction getManagedMemoryRangeFraction(final Configuration config) { + final MemorySize minSize = new MemorySize(0); + final MemorySize maxSize = new MemorySize(Long.MAX_VALUE); + final double fraction = config.getFloat(TaskManagerOptions.MANAGED_MEMORY_FRACTION); + if (fraction >= 1 || fraction < 0) { + throw new IllegalConfigurationException("Configured Managed Memory fraction (" + + fraction + ") must be in [0, 1)."); + } + return new RangeFraction(minSize, maxSize, fraction); + } + + private static double getManagedMemoryOffHeapFraction(final Configuration config) { + checkArgument(isManagedMemoryOffHeapFractionExplicitlyConfigured(config)); + final double offHeapFraction = config.getFloat(TaskManagerOptions.MANAGED_MEMORY_OFFHEAP_FRACTION); + if (offHeapFraction > 1 || offHeapFraction < 0) { + throw new IllegalConfigurationException("Configured Off-Heap Managed Memory fraction (" + + offHeapFraction + ") must be in [0, 1]."); + } + return offHeapFraction; + } + + private static MemorySize getManagedMemoryOffHeapSize(final Configuration config) { + checkArgument(isManagedMemoryOffHeapSizeExplicitlyConfigured(config)); + return MemorySize.parse(config.getString(TaskManagerOptions.MANAGED_MEMORY_OFFHEAP_SIZE)); + } + + @SuppressWarnings("deprecation") + private static MemorySize getShuffleMemorySizeWithLegacyConfig(final Configuration config) { + checkArgument(isUsingLegacyShuffleConfigs(config)); + final long numOfBuffers = config.getInteger(NettyShuffleEnvironmentOptions.NETWORK_NUM_BUFFERS); + final long pageSize = ConfigurationParserUtils.getPageSize(config); + return new MemorySize(numOfBuffers * pageSize); + } + + private static RangeFraction getShuffleMemoryRangeFraction(final Configuration config) { + final MemorySize minSize = MemorySize.parse(config.getString(TaskManagerOptions.SHUFFLE_MEMORY_MIN)); + final MemorySize maxSize = MemorySize.parse(config.getString(TaskManagerOptions.SHUFFLE_MEMORY_MAX)); + final double fraction = config.getFloat(TaskManagerOptions.SHUFFLE_MEMORY_FRACTION); + if (fraction >= 1 || fraction < 0) { + throw new IllegalConfigurationException("Configured Shuffle Memory fraction (" + + fraction + ") must be in [0, 1)."); + } + return new RangeFraction(minSize, maxSize, fraction); + } + + private static MemorySize getJvmMetaspaceSize(final Configuration config) { + return MemorySize.parse(config.getString(TaskManagerOptions.JVM_METASPACE)); + } + + private static RangeFraction getJvmOverheadRangeFraction(final Configuration config) { + final MemorySize minSize = MemorySize.parse(config.getString(TaskManagerOptions.JVM_OVERHEAD_MIN)); + final MemorySize maxSize = MemorySize.parse(config.getString(TaskManagerOptions.JVM_OVERHEAD_MAX)); + final double fraction = config.getFloat(TaskManagerOptions.JVM_OVERHEAD_FRACTION); + if (fraction >= 1 || fraction < 0) { + throw new IllegalConfigurationException("Configured JVM Overhead fraction (" + + fraction + ") must be in [0, 1)."); + } + return new RangeFraction(minSize, maxSize, fraction); + } + + @SuppressWarnings("deprecation") + private static MemorySize getTotalFlinkMemorySize(final Configuration config) { + checkArgument(isTotalFlinkMemorySizeExplicitlyConfigured(config)); + if (config.contains(TaskManagerOptions.TOTAL_FLINK_MEMORY)) { + return MemorySize.parse(config.getString(TaskManagerOptions.TOTAL_FLINK_MEMORY)); + } else { + final long legacyHeapMemoryMB = config.getInteger(TaskManagerOptions.TASK_MANAGER_HEAP_MEMORY_MB); + return new MemorySize(legacyHeapMemoryMB << 20); // megabytes to bytes + } + } + + private static MemorySize getTotalProcessMemorySize(final Configuration config) { + checkArgument(isTotalProcessMemorySizeExplicitlyConfigured(config)); + return MemorySize.parse(config.getString(TaskManagerOptions.TOTAL_PROCESS_MEMORY)); + } + + private static boolean isTaskHeapMemorySizeExplicitlyConfigured(final Configuration config) { + return config.contains(TaskManagerOptions.TASK_HEAP_MEMORY); + } + + private static boolean isManagedMemorySizeExplicitlyConfigured(final Configuration config) { + return config.contains(TaskManagerOptions.MANAGED_MEMORY_SIZE); + } + + private static boolean isManagedMemoryOffHeapFractionExplicitlyConfigured(final Configuration config) { + return config.getFloat(TaskManagerOptions.MANAGED_MEMORY_OFFHEAP_FRACTION) >= 0; + } + + private static boolean isManagedMemoryOffHeapSizeExplicitlyConfigured(final Configuration config) { + return config.contains(TaskManagerOptions.MANAGED_MEMORY_OFFHEAP_SIZE); + } + + @SuppressWarnings("deprecation") Review comment: Same here. ---------------------------------------------------------------- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. For queries about this service, please contact Infrastructure at: us...@infra.apache.org With regards, Apache Git Services
