feat(recommender): add round cpu millicores

vertical-pod-autoscaler/docs/features.md

@@ -34,4 +34,20 @@ Note: Due to the conversion to binary units and decimal place rounding, the huma
 To enable this feature, set the `--humanize-memory` flag to true when running the VPA recommender:
 ```bash
 --humanize-memory=true
+```
+
+## CPU Recommendation Rounding
+
+VPA can now provide CPU recommendations rounded to user-specified values, making it easier to interpret and configure resources. This feature is controlled by the `--round-cpu-millicores` flag in the recommender component.
+
+When enabled, CPU recommendations will be:
+- Rounded to the nearest multiple of the specified millicore value
+- Applied to target, lower bound, and upper bound recommendations
+
+For example, with `--round-cpu-millicores=50`, a CPU recommendation of `79m` would be rounded to `100m`, and a recommendation of `34m` would be rounded to `50m`.
+
+To enable this feature, set the --round-cpu-millicores flag when running the VPA recommender:
+
+```bash
+--round-cpu-millicores=50
 ```

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

@@ -35,6 +35,7 @@ var (
 	lowerBoundMemoryPercentile = flag.Float64("recommendation-lower-bound-memory-percentile", 0.5, `Memory usage percentile that will be used for the lower bound on memory recommendation.`)
 	upperBoundMemoryPercentile = flag.Float64("recommendation-upper-bound-memory-percentile", 0.95, `Memory usage percentile that will be used for the upper bound on memory recommendation.`)
 	humanizeMemory             = flag.Bool("humanize-memory", false, "Convert memory values in recommendations to the highest appropriate SI unit with up to 2 decimal places for better readability.")
+	roundCPUMillicores         = flag.Int("round-cpu-millicores", 1, `CPU recommendation rounding factor in millicores. The CPU value will be rounded to the nearest multiple of this factor.`)
 )
 
 // PodResourceRecommender computes resource recommendation for a Vpa object.
@@ -189,10 +190,10 @@ func MapToListOfRecommendedContainerResources(resources RecommendedPodResources)
 	for _, name := range containerNames {
 		containerResources = append(containerResources, vpa_types.RecommendedContainerResources{
 			ContainerName:  name,
-			Target:         model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory),
-			LowerBound:     model.ResourcesAsResourceList(resources[name].LowerBound, *humanizeMemory),
-			UpperBound:     model.ResourcesAsResourceList(resources[name].UpperBound, *humanizeMemory),
-			UncappedTarget: model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory),
+			Target:         model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores),
+			LowerBound:     model.ResourcesAsResourceList(resources[name].LowerBound, *humanizeMemory, *roundCPUMillicores),
+			UpperBound:     model.ResourcesAsResourceList(resources[name].UpperBound, *humanizeMemory, *roundCPUMillicores),
+			UncappedTarget: model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores),
 		})
 	}
 	recommendation := &vpa_types.RecommendedPodResources{

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

@@ -18,6 +18,7 @@ package model
 
 import (
 	"fmt"
+	"math"
 
 	apiv1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
@@ -81,7 +82,7 @@ func ScaleResource(amount ResourceAmount, factor float64) ResourceAmount {
 }
 
 // ResourcesAsResourceList converts internal Resources representation to ResourcesList.
-func ResourcesAsResourceList(resources Resources, humanizeMemory bool) apiv1.ResourceList {
+func ResourcesAsResourceList(resources Resources, humanizeMemory bool, roundCPUMillicores int) apiv1.ResourceList {
 	result := make(apiv1.ResourceList)
 	for key, resourceAmount := range resources {
 		var newKey apiv1.ResourceName
@@ -90,6 +91,15 @@ func ResourcesAsResourceList(resources Resources, humanizeMemory bool) apiv1.Res
 		case ResourceCPU:
 			newKey = apiv1.ResourceCPU
 			quantity = QuantityFromCPUAmount(resourceAmount)
+			if roundCPUMillicores != 1 && !quantity.IsZero() {
+				roundedValues, err := RoundUpToScale(resourceAmount, roundCPUMillicores)
+				if err != nil {
+					klog.V(4).InfoS("Error rounding CPU value; leaving unchanged", "rawValue", resourceAmount, "scale", roundCPUMillicores, "error", err)
+				} else {
+					klog.V(4).InfoS("Successfully rounded CPU value", "rawValue", resourceAmount, "roundedValue", roundedValues)
+				}
+				quantity = QuantityFromCPUAmount(roundedValues)
+			}
 		case ResourceMemory:
 			newKey = apiv1.ResourceMemory
 			quantity = QuantityFromMemoryAmount(resourceAmount)
@@ -166,6 +176,16 @@ func HumanizeMemoryQuantity(bytes int64) string {
 	}
 }
 
+// RoundUpToScale rounds the value to the nearest multiple of scale, rounding up
+func RoundUpToScale(value ResourceAmount, scale int) (ResourceAmount, error) {
+	if scale <= 0 {
+		return value, fmt.Errorf("scale must be greater than zero")
+	}
+	scale64 := int64(scale)
+	roundedValue := int64(math.Ceil(float64(value)/float64(scale64))) * scale64
+	return ResourceAmount(roundedValue), nil
+}
+
 // PodID contains information needed to identify a Pod within a cluster.
 type PodID struct {
 	// Namespaces where the Pod is defined.

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

@@ -28,75 +28,81 @@ type ResourcesAsResourceListTestCase struct {
 	name         string
 	resources    Resources
 	humanize     bool
+	roundCPU     int
 	resourceList apiv1.ResourceList
 }
 
 func TestResourcesAsResourceList(t *testing.T) {
 	testCases := []ResourcesAsResourceListTestCase{
 		{
-			name: "basic resources without humanize",
+			name: "basic resources without humanize and no cpu rounding",
 			resources: Resources{
 				ResourceCPU:    1000,
 				ResourceMemory: 1000,
 			},
 			humanize: false,
+			roundCPU: 1,
 			resourceList: apiv1.ResourceList{
 				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
 				apiv1.ResourceMemory: *resource.NewQuantity(1000, resource.DecimalSI),
 			},
 		},
 		{
-			name: "basic resources with humanize",
+			name: "basic resources with humanize and cpu rounding to 1",
 			resources: Resources{
 				ResourceCPU:    1000,
 				ResourceMemory: 262144000, // 250Mi
 			},
 			humanize: true,
+			roundCPU: 1,
 			resourceList: apiv1.ResourceList{
 				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
 				apiv1.ResourceMemory: resource.MustParse("250.00Mi"),
 			},
 		},
 		{
-			name: "large memory value with humanize",
+			name: "large memory value with humanize and cpu rounding to 3",
 			resources: Resources{
 				ResourceCPU:    1000,
 				ResourceMemory: 839500000, // 800.61Mi
 			},
 			humanize: true,
+			roundCPU: 3,
 			resourceList: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1002, resource.DecimalSI),
 				apiv1.ResourceMemory: resource.MustParse("800.61Mi"),
 			},
 		},
 		{
-			name: "zero values without humanize",
+			name: "zero values without humanize and cpu rounding to 2",
 			resources: Resources{
 				ResourceCPU:    0,
 				ResourceMemory: 0,
 			},
 			humanize: false,
+			roundCPU: 2,
 			resourceList: apiv1.ResourceList{
 				apiv1.ResourceCPU:    *resource.NewMilliQuantity(0, resource.DecimalSI),
 				apiv1.ResourceMemory: *resource.NewQuantity(0, resource.DecimalSI),
 			},
 		},
 		{
-			name: "large memory value without humanize",
+			name: "large memory value without humanize and cpu rounding to 13",
 			resources: Resources{
-				ResourceCPU:    1000,
+				ResourceCPU:    1231241,
 				ResourceMemory: 839500000,
 			},
 			humanize: false,
+			roundCPU: 13,
 			resourceList: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
+				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1231243, resource.DecimalSI),
 				apiv1.ResourceMemory: *resource.NewQuantity(839500000, resource.DecimalSI),
 			},
 		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			result := ResourcesAsResourceList(tc.resources, tc.humanize)
+			result := ResourcesAsResourceList(tc.resources, tc.humanize, tc.roundCPU)
 			if !result[apiv1.ResourceCPU].Equal(tc.resourceList[apiv1.ResourceCPU]) {
 				t.Errorf("expected %v, got %v", tc.resourceList[apiv1.ResourceCPU], result[apiv1.ResourceCPU])
 			}
@@ -194,6 +200,63 @@ func TestHumanizeMemoryQuantity(t *testing.T) {
 	}
 }
 
+type TestRoundUpToScaleTestCase struct {
+	name        string
+	value       ResourceAmount
+	scale       int
+	expected    ResourceAmount
+	expectedErr string
+}
+
+func TestRoundUpToScale(t *testing.T) {
+	testsCases := []TestRoundUpToScaleTestCase{
+		{
+			name:        "Round up to nearest 7",
+			value:       ResourceAmount(100),
+			scale:       7,
+			expected:    ResourceAmount(105),
+			expectedErr: "",
+		},
+		{
+			name:        "Exact multiple of 10",
+			value:       ResourceAmount(100),
+			scale:       10,
+			expected:    ResourceAmount(100),
+			expectedErr: "",
+		},
+		{
+			name:        "Zero value with scale 5",
+			value:       ResourceAmount(0),
+			scale:       5,
+			expected:    ResourceAmount(0),
+			expectedErr: "",
+		},
+		{
+			name:        "Negative scale value",
+			value:       ResourceAmount(100),
+			scale:       -5,
+			expected:    ResourceAmount(100),
+			expectedErr: "scale must be greater than zero",
+		},
+		{
+			name:        "Scale is zero",
+			value:       ResourceAmount(100),
+			scale:       0,
+			expected:    ResourceAmount(100),
+			expectedErr: "scale must be greater than zero",
+		},
+	}
+	for _, tc := range testsCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := RoundUpToScale(tc.value, tc.scale)
+			assert.Equal(t, tc.expected, result)
+			if tc.expectedErr != "" {
+				assert.Equal(t, tc.expectedErr, err.Error())
+			}
+		})
+	}
+}
+
 type CPUAmountFromCoresTestCase struct {
 	name  string
 	cores float64