ComputeClass request downscaling for overprovisioning (#2381) (#2394)

Author: Oscar Ward

docs/docs/40-admin/03-computeclasses.md

@@ -21,6 +21,7 @@ memory:
   min: 1Gi
   max: 2Gi
   default: 1Gi # This default overrides the install-wide memory default
+  requestScaler: .5 # A percentage of memory to request in relation to the limit, will not go below a configured min value
   values: # Specific values that are only allowed to be used. Default must be included in these values and max/min cannot be set.
   - 1.5Gi
 cpuScaler: 1 # This is used as a ratio of how many VCPUs to schedule per Gibibyte of memory. In this case it is 1 to 1.

integration/client/computeclass/computeclass_test.go

@@ -180,6 +180,41 @@ func TestCreatingComputeClasses(t *testing.T) {
 			},
 			fail: true,
 		},
+		{
+			name:      "valid-values-with-scaler",
+			cpuScaler: 0.25,
+			memory: adminv1.ComputeClassMemory{
+				RequestScaler: 0.1,
+				Default:       "1Gi",
+				Values:        []string{"1Gi", "2Gi"},
+			},
+		},
+		{
+			name: "valid-scaler-upper-bound",
+			memory: adminv1.ComputeClassMemory{
+				RequestScaler: 1.0,
+			},
+		},
+		{
+			name: "valid-scaler-lower-bound",
+			memory: adminv1.ComputeClassMemory{
+				RequestScaler: 0,
+			},
+		},
+		{
+			name: "invalid-scaler-negative",
+			memory: adminv1.ComputeClassMemory{
+				RequestScaler: -0.1,
+			},
+			fail: true,
+		},
+		{
+			name: "invalid-scaler-too-large",
+			memory: adminv1.ComputeClassMemory{
+				RequestScaler: 1.1,
+			},
+			fail: true,
+		},
 	}
 
 	for _, tt := range checks {

pkg/apis/internal.acorn.io/v1/memory.go

@@ -46,7 +46,7 @@ func ValidateMemory(memSpec MemoryMap, containerName string, container Container
 		memMaximum = *specMemMaximum
 	}
 
-	// Determine which memory should be used to set the resource limit/requests. Gets set
+	// Determine which memory should be used to set the resource limit. Gets set
 	// 4 ways: User setting a specific workload, user setting all workloads, Acornfile, or
 	// from the apiv1.Config default.
 	memBytes, errType := memDefault, ErrInvalidDefaultMemory
@@ -80,7 +80,7 @@ func ValidateMemory(memSpec MemoryMap, containerName string, container Container
 					errType, defaultQuantity, maxQuantity)
 			}
 		} else if memBytes == 0 {
-			// For bytes, 0 is viewed as the maximum allowed memory". As such,
+			// For bytes, 0 is viewed as the maximum allowed memory. As such,
 			// update to the current maximum.
 			memBytes = memMaximum
 		}

pkg/apis/internal.admin.acorn.io/v1/computeclasses.go

@@ -65,8 +65,9 @@ type ProjectComputeClassInstanceList struct {
 }
 
 type ComputeClassMemory struct {
-	Min     string   `json:"min,omitempty"`
-	Max     string   `json:"max,omitempty"`
-	Default string   `json:"default,omitempty"`
-	Values  []string `json:"values,omitempty"`
+	Min           string   `json:"min,omitempty"`
+	Max           string   `json:"max,omitempty"`
+	Default       string   `json:"default,omitempty"`
+	RequestScaler float64  `json:"requestScaler,omitempty"`
+	Values        []string `json:"values,omitempty"`
 }

pkg/computeclasses/computeclasses.go

@@ -59,6 +59,10 @@ func ParseComputeClassMemory(memory internaladminv1.ComputeClassMemory) (memoryQ
 	}
 	quantities.Def = &defInt
 
+	if memory.RequestScaler < 0 || memory.RequestScaler > 1 {
+		return memoryQuantities{}, errors.New("request scaler value must be between 0 and 1, inclusive")
+	}
+
 	quantities.Values = make([]*resource.Quantity, len(memory.Values))
 	for i, value := range memory.Values {
 		valueInt, err := parseQuantity(value)

pkg/controller/scheduling/computeclass_test.go

@@ -61,6 +61,14 @@ func TestGenericResourcesComputeClass(t *testing.T) {
 	tester.DefaultTest(t, scheme.Scheme, "testdata/computeclass/generic-resources", Calculate)
 }
 
+func TestRequestScaler(t *testing.T) {
+	tester.DefaultTest(t, scheme.Scheme, "testdata/computeclass/request-scaler", Calculate)
+}
+
+func TestRequestScalerFloor(t *testing.T) {
+	tester.DefaultTest(t, scheme.Scheme, "testdata/computeclass/request-scaler-floor", Calculate)
+}
+
 func TestTwoCCCDefaultsShouldError(t *testing.T) {
 	harness, input, err := tester.FromDir(scheme.Scheme, "testdata/computeclass/two-ccc-defaults-should-error")
 	if err != nil {

pkg/controller/scheduling/scheduling.go

@@ -187,18 +187,36 @@ func ResourceRequirements(req router.Request, app *v1.AppInstance, containerName
 		}
 	}
 
-	memoryQuantity, err := v1.ValidateMemory(app.Spec.Memory, containerName, container, memDefault, memMax)
+	memoryLimit, err := v1.ValidateMemory(app.Spec.Memory, containerName, container, memDefault, memMax)
 	if err != nil {
 		return nil, err
 	}
 
-	if memoryQuantity.Value() != 0 {
-		requirements.Requests[corev1.ResourceMemory] = memoryQuantity
-		requirements.Limits[corev1.ResourceMemory] = memoryQuantity
+	// Figure out the scaled value of memory to request based on the compute class
+	memoryRequest := memoryLimit.DeepCopy()
+	if computeClass != nil && computeClass.Memory.RequestScaler != 0 {
+		// The following line should hold up without loss of precision up to 4 petabytes
+		memoryRequest.Set(int64(memoryLimit.AsApproximateFloat64() * computeClass.Memory.RequestScaler))
+
+		// Never allocate less than the defined minimum of the compute class
+		if computeClass.Memory.Min != "" && computeClass.Memory.Min != "0" {
+			minValue, err := resource.ParseQuantity(computeClass.Memory.Min)
+			if err != nil {
+				return nil, err
+			}
+			if minValue.Cmp(memoryRequest) == 1 {
+				memoryRequest = minValue
+			}
+		}
+	}
+
+	if memoryLimit.Value() != 0 {
+		requirements.Requests[corev1.ResourceMemory] = memoryRequest
+		requirements.Limits[corev1.ResourceMemory] = memoryLimit
 	}
 
 	if computeClass != nil {
-		cpuQuantity, err := computeclasses.CalculateCPU(*computeClass, memDefault, memoryQuantity)
+		cpuQuantity, err := computeclasses.CalculateCPU(*computeClass, memDefault, memoryRequest)
 		if err != nil {
 			return nil, err
 		}

pkg/controller/scheduling/testdata/computeclass/request-scaler-floor/existing.yaml

@@ -0,0 +1,21 @@
+---
+kind: ClusterComputeClassInstance
+apiVersion: internal.admin.acorn.io/v1
+metadata:
+  name: sample-compute-class
+description: Simple description for a simple ComputeClass
+cpuScaler: 0.25
+memory:
+  min: 1Mi # 1Mi
+  max: 2Mi # 2Mi
+  default: 2Mi # 2Mi
+  requestScaler: .1
+affinity:
+  nodeAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+      nodeSelectorTerms:
+      - matchExpressions:
+        - key: foo
+          operator: In
+          values:
+          - bar

pkg/controller/scheduling/testdata/computeclass/request-scaler-floor/expected.golden

@@ -0,0 +1,88 @@
+`apiVersion: internal.acorn.io/v1
+kind: AppInstance
+metadata:
+  creationTimestamp: null
+  name: app-name
+  namespace: app-namespace
+  uid: 1234567890abcdef
+spec:
+  computeClass:
+    oneimage: sample-compute-class
+  image: test
+status:
+  appImage:
+    buildContext: {}
+    id: test
+    imageData: {}
+    vcs: {}
+  appSpec:
+    containers:
+      oneimage:
+        build:
+          context: .
+          dockerfile: Dockerfile
+        image: image-name
+        metrics: {}
+        ports:
+        - port: 80
+          protocol: http
+          targetPort: 81
+        probes: null
+        sidecars:
+          left:
+            image: foo
+            metrics: {}
+            ports:
+            - port: 90
+              protocol: tcp
+              targetPort: 91
+            probes: null
+  appStatus: {}
+  columns: {}
+  conditions:
+    reason: Success
+    status: "True"
+    success: true
+    type: scheduling
+  defaults:
+    memory:
+      "": 0
+      left: 2097152
+      oneimage: 2097152
+  namespace: app-created-namespace
+  observedGeneration: 1
+  resolvedOfferings: {}
+  scheduling:
+    left:
+      requirements:
+        limits:
+          memory: 2Mi
+        requests:
+          cpu: 1m
+          memory: 1Mi
+    oneimage:
+      affinity:
+        nodeAffinity:
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+            - matchExpressions:
+              - key: foo
+                operator: In
+                values:
+                - bar
+      requirements:
+        limits:
+          memory: 2Mi
+        requests:
+          cpu: 1m
+          memory: 1Mi
+      tolerations:
+      - key: taints.acorn.io/workload
+        operator: Exists
+  staged:
+    appImage:
+      buildContext: {}
+      imageData: {}
+      vcs: {}
+  summary: {}
+`

pkg/controller/scheduling/testdata/computeclass/request-scaler-floor/input.yaml

@@ -0,0 +1,39 @@
+kind: AppInstance
+apiVersion: internal.acorn.io/v1
+metadata:
+  name: app-name
+  namespace: app-namespace
+  uid: 1234567890abcdef
+spec:
+  image: test
+  computeClass:
+    oneimage: sample-compute-class
+status:
+  observedGeneration: 1
+  defaults:
+    memory:
+      "": 0
+      left: 2097152 # 2Mi
+      oneimage: 2097152 # 2Mi
+  namespace: app-created-namespace
+  appImage:
+    id: test
+    defaults:
+  appSpec:
+    containers:
+      oneimage:
+        sidecars:
+          left:
+            image: "foo"
+            ports:
+              - port: 90
+                targetPort: 91
+                protocol: tcp
+        ports:
+        - port: 80
+          targetPort: 81
+          protocol: http
+        image: "image-name"
+        build:
+          dockerfile: "Dockerfile"
+          context: "."