feat(recommender): add enforce cpu memory ratio

Author: Jrmy2402

vertical-pod-autoscaler/docs/flags.md

@@ -66,6 +66,7 @@ This document is auto-generated from the flag definitions in the VPA recommender
 | `container-recommendation-max-allowed-memory` |  |  | quantity   Maximum amount of memory that will be recommended for a container. VerticalPodAutoscaler-level maximum allowed takes precedence over the global maximum allowed. |
 | `cpu-histogram-decay-half-life` |  |  24h0m0s | duration                 The amount of time it takes a historical CPU usage sample to lose half of its weight.  |
 | `cpu-integer-post-processor-enabled` |  |  | Enable the cpu-integer recommendation post processor. The post processor will round up CPU recommendations to a whole CPU for pods which were opted in by setting an appropriate label on VPA object (experimental) |
+| `enforce-cpu-memory-ratio` | float |  | If > 0, enforce a fixed memory-per-CPU ratio expressed as bytes per millicores across all recommendations. |
 | `external-metrics-cpu-metric` | string |  | ALPHA.  Metric to use with external metrics provider for CPU usage. |
 | `external-metrics-memory-metric` | string |  | ALPHA.  Metric to use with external metrics provider for memory usage. |
 | `feature-gates` | mapStringBool |  | A set of key=value pairs that describe feature gates for alpha/experimental features. Options are:<br>AllAlpha=true\|false (ALPHA - default=false)<br>AllBeta=true\|false (BETA - default=false)<br>InPlaceOrRecreate=true\|false (BETA - default=true) |

vertical-pod-autoscaler/pkg/recommender/logic/recommender.go

@@ -40,6 +40,7 @@ var (
 	humanizeMemory             = flag.Bool("humanize-memory", false, "DEPRECATED: Convert memory values in recommendations to the highest appropriate SI unit with up to 2 decimal places for better readability. This flag is deprecated and will be removed in a future version. Use --round-memory-bytes instead.")
 	roundCPUMillicores         = flag.Int("round-cpu-millicores", 1, `CPU recommendation rounding factor in millicores. The CPU value will always be rounded up to the nearest multiple of this factor.`)
 	roundMemoryBytes           = flag.Int("round-memory-bytes", 1, `Memory recommendation rounding factor in bytes. The Memory value will always be rounded up to the nearest multiple of this factor.`)
+	enforceCPUMemoryRatio      = flag.Float64("enforce-cpu-memory-ratio", 0, `If > 0, enforce a fixed memory-per-CPU ratio expressed as bytes per millicores across all recommendations.`)
 )
 
 // PodResourceRecommender computes resource recommendation for a Vpa object.
@@ -194,10 +195,10 @@ func MapToListOfRecommendedContainerResources(resources RecommendedPodResources)
 	for _, name := range containerNames {
 		containerResources = append(containerResources, vpa_types.RecommendedContainerResources{
 			ContainerName:  name,
-			Target:         model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
-			LowerBound:     model.ResourcesAsResourceList(resources[name].LowerBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
-			UpperBound:     model.ResourcesAsResourceList(resources[name].UpperBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
-			UncappedTarget: model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
+			Target:         model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
+			LowerBound:     model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].LowerBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
+			UpperBound:     model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].UpperBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
+			UncappedTarget: model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
 		})
 	}
 	recommendation := &vpa_types.RecommendedPodResources{

vertical-pod-autoscaler/pkg/recommender/model/types.go

@@ -81,6 +81,40 @@ func ScaleResource(amount ResourceAmount, factor float64) ResourceAmount {
 	return resourceAmountFromFloat(float64(amount) * factor)
 }
 
+// EnforceCPUMemoryRatio adjusts the CPU or Memory to maintain a fixed ratio in bytes per millicore.
+// If the actual memory per millicore is too low, memory is increased.
+// If it is too high, CPU is increased.
+func EnforceCPUMemoryRatio(resources apiv1.ResourceList, ratioBytesPerMillicore *float64) apiv1.ResourceList {
+	if ratioBytesPerMillicore == nil || *ratioBytesPerMillicore <= 0 {
+		// No ratio specified or invalid ratio, nothing to do
+		return resources
+	}
+
+	cpuQty, hasCPU := resources[apiv1.ResourceCPU]
+	memQty, hasMem := resources[apiv1.ResourceMemory]
+
+	if !hasCPU || !hasMem || cpuQty.IsZero() || memQty.IsZero() {
+		return resources
+	}
+
+	cpuMilli := float64(cpuQty.MilliValue())
+	memBytes := float64(memQty.Value())
+
+	currentRatio := memBytes / cpuMilli
+
+	if currentRatio < *ratioBytesPerMillicore {
+		// Not enough RAM for the given CPU → increase memory
+		desiredMem := cpuMilli * *ratioBytesPerMillicore
+		resources[apiv1.ResourceMemory] = *resource.NewQuantity(int64(desiredMem), resource.BinarySI)
+	} else if currentRatio > *ratioBytesPerMillicore {
+		// Too much RAM for the given CPU → increase CPU
+		desiredCPU := memBytes / *ratioBytesPerMillicore
+		resources[apiv1.ResourceCPU] = *resource.NewMilliQuantity(int64(desiredCPU), resource.DecimalSI)
+	}
+
+	return resources
+}
+
 // ResourcesAsResourceList converts internal Resources representation to ResourcesList.
 func ResourcesAsResourceList(resources Resources, humanizeMemory bool, roundCPUMillicores, roundMemoryBytes int) apiv1.ResourceList {
 	result := make(apiv1.ResourceList)

vertical-pod-autoscaler/pkg/recommender/model/types_test.go

@@ -758,3 +758,100 @@ func TestResourceAmountFromFloat(t *testing.T) {
 		})
 	}
 }
+
+type EnforceCPUMemoryRatioTestCase struct {
+	name     string
+	input    apiv1.ResourceList
+	ratio    *float64
+	expected apiv1.ResourceList
+}
+
+func TestEnforceCPUMemoryRatio2(t *testing.T) {
+	// 1 CPU -> 4 GiB  => bytes per millicore
+	ratio4GiBPerCore := float64(4*1024*1024*1024) / 1000.0 // 4_294_967.296
+
+	tc := []EnforceCPUMemoryRatioTestCase{
+		{
+			name: "no ratio provided",
+			input: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
+				apiv1.ResourceMemory: *resource.NewQuantity(4*1024*1024*1024, resource.BinarySI),
+			},
+			ratio: nil,
+			expected: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
+				apiv1.ResourceMemory: *resource.NewQuantity(4*1024*1024*1024, resource.BinarySI),
+			},
+		},
+		{
+			name: "valid ratio already respected",
+			input: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(2000, resource.DecimalSI),       // 2 cores
+				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI), // 8Gi
+			},
+			ratio: float64Ptr(ratio4GiBPerCore),
+			expected: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(2000, resource.DecimalSI),
+				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI),
+			},
+		},
+		{
+			name: "too much RAM, should increase CPU",
+			input: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),       // 1 core
+				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI), // 8Gi
+			},
+			ratio: float64Ptr(ratio4GiBPerCore),
+			expected: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(2000, resource.DecimalSI), // 8Gi / 4 = 2 cores
+				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI),
+			},
+		},
+		{
+			name: "not enough RAM, should increase RAM",
+			input: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(4000, resource.DecimalSI),       // 4 cores
+				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI), // 8Gi
+			},
+			ratio: float64Ptr(ratio4GiBPerCore),
+			expected: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(4000, resource.DecimalSI),
+				apiv1.ResourceMemory: *resource.NewQuantity(16*1024*1024*1024, resource.BinarySI), // 4 cores * 4 = 16Gi
+			},
+		},
+		{
+			name: "missing memory, no-op",
+			input: apiv1.ResourceList{
+				apiv1.ResourceCPU: *resource.NewMilliQuantity(1000, resource.DecimalSI),
+			},
+			ratio: float64Ptr(ratio4GiBPerCore),
+			expected: apiv1.ResourceList{
+				apiv1.ResourceCPU: *resource.NewMilliQuantity(1000, resource.DecimalSI),
+			},
+		},
+		{
+			name: "zero values, no-op",
+			input: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(0, resource.DecimalSI),
+				apiv1.ResourceMemory: *resource.NewQuantity(0, resource.BinarySI),
+			},
+			ratio: float64Ptr(ratio4GiBPerCore),
+			expected: apiv1.ResourceList{
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(0, resource.DecimalSI),
+				apiv1.ResourceMemory: *resource.NewQuantity(0, resource.BinarySI),
+			},
+		},
+	}
+
+	for _, tc := range tc {
+		t.Run(tc.name, func(t *testing.T) {
+			result := EnforceCPUMemoryRatio(tc.input.DeepCopy(), tc.ratio)
+			assert.Equal(t, tc.expected[apiv1.ResourceCPU], result[apiv1.ResourceCPU])
+			assert.Equal(t, tc.expected[apiv1.ResourceMemory], result[apiv1.ResourceMemory])
+		})
+	}
+}
+
+func float64Ptr(v float64) *float64 {
+	return &v
+}