mxm commented on code in PR #762: URL: https://github.com/apache/flink-kubernetes-operator/pull/762#discussion_r1482809329
########## flink-autoscaler/src/main/java/org/apache/flink/autoscaler/utils/MemoryTuningUtils.java: ########## @@ -0,0 +1,238 @@ +/* + * 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.autoscaler.utils; + +import org.apache.flink.autoscaler.JobAutoScalerContext; +import org.apache.flink.autoscaler.config.AutoScalerOptions; +import org.apache.flink.autoscaler.event.AutoScalerEventHandler; +import org.apache.flink.autoscaler.metrics.EvaluatedMetrics; +import org.apache.flink.autoscaler.metrics.ScalingMetric; +import org.apache.flink.configuration.Configuration; +import org.apache.flink.configuration.IllegalConfigurationException; +import org.apache.flink.configuration.MemorySize; +import org.apache.flink.configuration.StateBackendOptions; +import org.apache.flink.configuration.TaskManagerOptions; +import org.apache.flink.configuration.UnmodifiableConfiguration; +import org.apache.flink.runtime.util.config.memory.CommonProcessMemorySpec; +import org.apache.flink.runtime.util.config.memory.JvmMetaspaceAndOverheadOptions; +import org.apache.flink.runtime.util.config.memory.ProcessMemoryOptions; +import org.apache.flink.runtime.util.config.memory.ProcessMemoryUtils; +import org.apache.flink.runtime.util.config.memory.taskmanager.TaskExecutorFlinkMemory; +import org.apache.flink.runtime.util.config.memory.taskmanager.TaskExecutorFlinkMemoryUtils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Arrays; +import java.util.Map; + +/** Tunes the TaskManager memory. */ +public class MemoryTuningUtils { + + private static final Logger LOG = LoggerFactory.getLogger(MemoryTuningUtils.class); + public static final ProcessMemoryUtils<TaskExecutorFlinkMemory> FLINK_MEMORY_UTILS = + new ProcessMemoryUtils<>(getMemoryOptions(), new TaskExecutorFlinkMemoryUtils()); + + private static final Configuration EMPTY_CONFIG = new Configuration(); + + /** + * Emits a Configuration which contains overrides for the current configuration. We are not + * modifying the config directly, but we are emitting a new configuration which contains any + * overrides. This config is persisted separately and applied by the autoscaler. That way we can + * clear any applied overrides if auto-tuning is disabled. + */ + public static Configuration tuneTaskManagerHeapMemory( + JobAutoScalerContext<?> context, + EvaluatedMetrics evaluatedMetrics, + AutoScalerEventHandler eventHandler) { + + // Please note that this config is the original configuration created from the user spec. + // It does not contain any already applied overrides. + var config = new UnmodifiableConfiguration(context.getConfiguration()); + + // Gather original memory configuration from the user spec + CommonProcessMemorySpec<TaskExecutorFlinkMemory> memSpecs; + try { + memSpecs = FLINK_MEMORY_UTILS.memoryProcessSpecFromConfig(config); + } catch (IllegalConfigurationException e) { + LOG.warn("Current memory configuration is not valid. Aborting memory tuning."); + return EMPTY_CONFIG; + } + + var maxHeapSize = memSpecs.getFlinkMemory().getJvmHeapMemorySize(); + LOG.info("Current configured heap size: {}", maxHeapSize); + + MemorySize avgHeapSize = getAverageMemorySize(evaluatedMetrics); + + // Apply min/max heap size limits + MemorySize newHeapSize = + new MemorySize( + Math.min( + // Upper limit is the original max heap size in the spec + maxHeapSize.getBytes(), + Math.max( + // Lower limit is the minimum configured heap size + config.get(AutoScalerOptions.MEMORY_TUNING_MIN_HEAP) + .getBytes(), + avgHeapSize.getBytes()))); + LOG.info("New TM heap memory {}", newHeapSize.toHumanReadableString()); + + // Diff can be negative (memory shrinks) or positive (memory grows) + final long heapDiffBytes = newHeapSize.getBytes() - maxHeapSize.getBytes(); + + final MemorySize totalMemory = adjustTotalTmMemory(context, heapDiffBytes); + if (totalMemory.equals(MemorySize.ZERO)) { + return EMPTY_CONFIG; + } + + // Prepare the tuning config for new configuration values + var tuningConfig = new Configuration(); + // Update total memory according to new heap size + // Adjust the total container memory and the JVM heap size accordingly. + tuningConfig.set(TaskManagerOptions.TOTAL_PROCESS_MEMORY, totalMemory); + // Framework and Task heap memory configs add up together yield the max heap memory. + // To simplify the calculation, set the framework heap memory to zero. + tuningConfig.set(TaskManagerOptions.FRAMEWORK_HEAP_MEMORY, MemorySize.ZERO); + tuningConfig.set(TaskManagerOptions.TASK_HEAP_MEMORY, newHeapSize); + + // All memory options which can be configured via fractions need to be set to their + // absolute values or, if there is no absolute setting, the fractions need to be + // re-calculated. + MemorySize managedMemory = memSpecs.getFlinkMemory().getManaged(); + if (shouldTransferHeapToManagedMemory(config, heapDiffBytes)) { + // If RocksDB is configured, give back the heap memory as managed memory to RocksDB + MemorySize newManagedMemory = + new MemorySize(managedMemory.getBytes() + Math.abs(heapDiffBytes)); + LOG.info( + "Increasing managed memory size from {} to {}", + managedMemory, + newManagedMemory); + tuningConfig.set(TaskManagerOptions.MANAGED_MEMORY_SIZE, newManagedMemory); + } else { + tuningConfig.set(TaskManagerOptions.MANAGED_MEMORY_SIZE, managedMemory); + } + + tuningConfig.set( + TaskManagerOptions.NETWORK_MEMORY_FRACTION, + getFraction( + memSpecs.getFlinkMemory().getNetwork(), + new MemorySize( + memSpecs.getTotalFlinkMemorySize().getBytes() + heapDiffBytes))); + tuningConfig.set( + TaskManagerOptions.JVM_OVERHEAD_FRACTION, + getFraction(memSpecs.getJvmOverheadSize(), totalMemory)); + + eventHandler.handleEvent( + context, + AutoScalerEventHandler.Type.Normal, + "Configuration recommendation", + String.format( + "Memory tuning recommends the following configuration (automatic tuning is %s):\n%s", + config.get(AutoScalerOptions.MEMORY_TUNING_ENABLED) + ? "enabled" + : "disabled", + formatConfig(tuningConfig)), + "MemoryTuning", + null); Review Comment: The idea is to add tuning recommendations even when we don't automatically apply updates. That was heavily requested by users. The tuning is only called on scaling decisions where we also emit a scaling event. I agree that once we decouple the tuning from the scaling, we should only emit recommendations every N minutes. -- 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. To unsubscribe, e-mail: issues-unsubscr...@flink.apache.org For queries about this service, please contact Infrastructure at: us...@infra.apache.org
