Adding OOM Score adjustment formula changes that takes pod level resources into account

Signed-off-by: ndixita <[email protected]>

Author: ndixita

pkg/kubelet/qos/helpers.go

@@ -27,6 +27,7 @@ package qos // import "k8s.io/kubernetes/pkg/kubelet/qos"
 
 import (
 	v1 "k8s.io/api/core/v1"
+	resourcehelper "k8s.io/component-helpers/resource"
 )
 
 // minRegularContainerMemory returns the minimum memory resource quantity
@@ -41,3 +42,30 @@ func minRegularContainerMemory(pod v1.Pod) int64 {
 	}
 	return memoryValue
 }
+
+// remainingPodMemReqPerContainer calculates the remaining pod memory request per
+// container by:
+// 1. Taking the total pod memory requests
+// 2. Subtracting total container memory requests from pod memory requests
+// 3. Dividing the remainder by the number of containers.
+// This gives us the additional memory request that is not allocated to any
+// containers in the pod. This value will be divided equally among all containers to
+// calculate oom score adjusment.
+// See https://github.com/kubernetes/enhancements/blob/master/keps/sig-node/2837-pod-level-resource-spec/README.md#oom-score-adjustment
+// for more details.
+func remainingPodMemReqPerContainer(pod *v1.Pod) int64 {
+	var remainingMemory int64
+	if pod.Spec.Resources.Requests.Memory().IsZero() {
+		return remainingMemory
+	}
+
+	numContainers := len(pod.Spec.Containers) + len(pod.Spec.InitContainers)
+
+	// Aggregated requests of all containers.
+	aggrContainerReqs := resourcehelper.AggregateContainerRequests(pod, resourcehelper.PodResourcesOptions{})
+
+	remainingMemory = pod.Spec.Resources.Requests.Memory().Value() - aggrContainerReqs.Memory().Value()
+
+	remainingMemoryPerContainer := remainingMemory / int64(numContainers)
+	return remainingMemoryPerContainer
+}

pkg/kubelet/qos/policy.go

@@ -19,6 +19,7 @@ package qos
 import (
 	v1 "k8s.io/api/core/v1"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	resourcehelper "k8s.io/component-helpers/resource"
 	v1qos "k8s.io/kubernetes/pkg/apis/core/v1/helper/qos"
 	"k8s.io/kubernetes/pkg/features"
 	"k8s.io/kubernetes/pkg/kubelet/types"
@@ -63,14 +64,41 @@ func GetContainerOOMScoreAdjust(pod *v1.Pod, container *v1.Container, memoryCapa
 	// which use more than their request will have an OOM score of 1000 and will be prime
 	// targets for OOM kills.
 	// Note that this is a heuristic, it won't work if a container has many small processes.
-	memoryRequest := container.Resources.Requests.Memory().Value()
-	oomScoreAdjust := 1000 - (1000*memoryRequest)/memoryCapacity
+	containerMemReq := container.Resources.Requests.Memory().Value()
+
+	var oomScoreAdjust, remainingReqPerContainer int64
+	// When PodLevelResources feature is enabled, the OOM score adjustment formula is modified
+	// to account for pod-level memory requests. Any extra pod memory request that's
+	// not allocated to the containers is divided equally among all containers and
+	// added to their individual memory requests when calculating the OOM score
+	// adjustment. Otherwise, only container-level memory requests are used. See
+	// https://github.com/kubernetes/enhancements/blob/master/keps/sig-node/2837-pod-level-resource-spec/README.md#oom-score-adjustment
+	// for more details.
+	if utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) &&
+		resourcehelper.IsPodLevelRequestsSet(pod) {
+		// TODO(ndixita): Refactor to use this formula in all cases, as
+		// remainingReqPerContainer will be 0 when pod-level resources are not set.
+		remainingReqPerContainer = remainingPodMemReqPerContainer(pod)
+		oomScoreAdjust = 1000 - (1000 * (containerMemReq + remainingReqPerContainer) / memoryCapacity)
+	} else {
+		oomScoreAdjust = 1000 - (1000*containerMemReq)/memoryCapacity
+	}
 
 	// adapt the sidecarContainer memoryRequest for OOM ADJ calculation
 	// calculate the oom score adjustment based on: max-memory( currentSideCarContainer , min-memory(regular containers) ) .
 	if utilfeature.DefaultFeatureGate.Enabled(features.SidecarContainers) && isSidecarContainer(pod, container) {
 		// check min memory quantity in regular containers
 		minMemoryRequest := minRegularContainerMemory(*pod)
+
+		// When calculating minMemoryOomScoreAdjust for sidecar containers with PodLevelResources enabled,
+		// we add the per-container share of unallocated pod memory requests to the minimum memory request.
+		// This ensures the OOM score adjustment i.e. minMemoryOomScoreAdjust
+		// calculation remains consistent
+		//  with how we handle pod-level memory requests for regular containers.
+		if utilfeature.DefaultFeatureGate.Enabled(features.PodLevelResources) &&
+			resourcehelper.IsPodLevelRequestsSet(pod) {
+			minMemoryRequest += remainingReqPerContainer
+		}
 		minMemoryOomScoreAdjust := 1000 - (1000*minMemoryRequest)/memoryCapacity
 		// the OOM adjustment for sidecar container will match
 		// or fall below the OOM score adjustment of regular containers in the Pod.