Implementing maxAvailableComponentSets for resource models

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

Author: mszacillo

pkg/estimator/client/general.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"fmt"
 	"math"
+	"sort"
 
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
@@ -149,8 +150,7 @@ func (ge *GeneralEstimator) maxAvailableComponentSets(cluster *clusterv1alpha1.C
 	}
 
 	if features.FeatureGate.Enabled(features.CustomizedClusterResourceModeling) && len(cluster.Status.ResourceSummary.AllocatableModelings) > 0 {
-		num, err := getMaximumSetsBasedOnResourceModels(cluster, components)
-		if err != nil {
+		if num, err := getMaximumSetsBasedOnResourceModels(cluster, components, podBound); err != nil {
 			klog.Warningf("Failed to get maximum sets based on resource models, skipping: %v", err)
 		} else if num < maxSets {
 			maxSets = num
@@ -160,13 +160,197 @@ func (ge *GeneralEstimator) maxAvailableComponentSets(cluster *clusterv1alpha1.C
 	return int32(maxSets) // #nosec G115: integer overflow conversion int64 -> int32
 }
 
-// getMaximumSetsBasedOnResourceModels is a placeholder for future implementation.
-// It should refine the maximum sets based on cluster resource models, similar
-// to getMaximumReplicasBasedOnResourceModels but adapted to full component sets.
-func getMaximumSetsBasedOnResourceModels(_ *clusterv1alpha1.Cluster, _ []workv1alpha2.Component) (int64, error) {
-	// TODO: implement logic based on cluster.Spec.ResourceModels
-	// For now, just return MaxInt64 so it never reduces the upper bound.
-	return math.MaxInt64, nil
+// getMaximumSetsBasedOnResourceModels computes the maximum number of full sets that can be
+// placed on a cluster using the cluster's ResourceModels. It expands one set into individual component replicas
+// and performs a first-fit-decreasing placement onto model-grade nodes.
+// `upperBound` caps the search. We can this using the podBound (allowedPods / podsPerSet)
+func getMaximumSetsBasedOnResourceModels(
+	cluster *clusterv1alpha1.Cluster,
+	components []workv1alpha2.Component,
+	upperBound int64,
+) (int64, error) {
+	if upperBound <= 0 {
+		return 0, nil
+	}
+
+	// Build model nodes from Spec.ResourceModels and Status.AllocatableModelings
+	nodes, err := buildModelNodes(cluster)
+	if err != nil {
+		return -1, err
+	}
+	if len(nodes) == 0 {
+		return 0, nil
+	}
+
+	// Expand one set into per-replica resource maps
+	oneSet := expandReplicasOneSet(components)
+	if len(oneSet) == 0 {
+		// No pods in a set -> nothing to schedule under models
+		return 0, nil
+	}
+
+	// Binary search on #sets within [0, upperBound]
+	lo, hi := int64(0), upperBound
+	for lo < hi {
+		mid := (lo + hi + 1) / 2
+		if modelsFeasible(mid, oneSet, nodes) {
+			lo = mid
+		} else {
+			hi = mid - 1
+		}
+	}
+	return lo, nil
+}
+
+// ----- Models helpers -----
+
+// modelNode holds remaining capacity for a given node across all resource types
+type modelNode struct {
+	cap map[corev1.ResourceName]int64
+}
+
+// buildModelNodes constructs identical nodes for each model grade using its Min vector,
+// repeated `AllocatableModelings[i].Count` times.
+func buildModelNodes(cluster *clusterv1alpha1.Cluster) ([]modelNode, error) {
+	if len(cluster.Spec.ResourceModels) == 0 {
+		return nil, fmt.Errorf("resource model is inapplicable as no grades are defined")
+	}
+	// Convert Spec.ResourceModels to a map of resource -> []MinByGrade
+	minMap := convertToResourceModelsMinMap(cluster.Spec.ResourceModels)
+
+	// Build nodes for each grade index i
+	var nodes []modelNode
+	for i := 0; i < len(cluster.Spec.ResourceModels); i++ {
+		if i >= len(cluster.Status.ResourceSummary.AllocatableModelings) {
+			// Shouldn’t happen — status is malformed
+			return nil, fmt.Errorf("resource model/status mismatch: %d grades in spec, %d in status",
+				len(cluster.Spec.ResourceModels), len(cluster.Status.ResourceSummary.AllocatableModelings))
+		}
+
+		count := cluster.Status.ResourceSummary.AllocatableModelings[i].Count
+		if count == 0 {
+			continue
+		}
+
+		// Capacity vector for this grade = Min boundary of each resource at grade i (normalized)
+		capTemplate := make(map[corev1.ResourceName]int64, len(minMap))
+		for resName, mins := range minMap {
+			if i >= len(mins) {
+				// Model shape mismatch; treat as missing resource for this grade
+				return nil, fmt.Errorf("resource model is inapplicable as missing resource %q in grade %d", string(resName), i)
+			}
+			capTemplate[resName] = quantityAsInt64(mins[i])
+		}
+
+		// Append `count` identical nodes of this grade
+		for n := 0; n < count; n++ {
+			// Copy capTemplate to each node
+			capCopy := make(map[corev1.ResourceName]int64, len(capTemplate))
+			for k, v := range capTemplate {
+				capCopy[k] = v
+			}
+			nodes = append(nodes, modelNode{cap: capCopy})
+		}
+	}
+	return nodes, nil
+}
+
+// expandReplicasOneSet flattens components into a slice of per-replica demand maps
+func expandReplicasOneSet(components []workv1alpha2.Component) []map[corev1.ResourceName]int64 {
+	var reps []map[corev1.ResourceName]int64
+	for _, c := range components {
+		if c.ReplicaRequirements == nil || c.ReplicaRequirements.ResourceRequest == nil {
+			continue
+		}
+		// Build normalized demand once per component
+		base := make(map[corev1.ResourceName]int64, len(c.ReplicaRequirements.ResourceRequest))
+		for name, qty := range c.ReplicaRequirements.ResourceRequest {
+			base[name] = quantityAsInt64(qty)
+		}
+		// Repeat for the number of replicas in the component
+		for i := int32(0); i < c.Replicas; i++ {
+			m := make(map[corev1.ResourceName]int64, len(base))
+			for k, v := range base {
+				m[k] = v
+			}
+			reps = append(reps, m)
+		}
+	}
+	return reps
+}
+
+// modelsFeasible checks if the given # of copies of `oneSet` can be placed onto `nodes`
+// using first-fit decreasing to for packing
+func modelsFeasible(sets int64, oneSet []map[corev1.ResourceName]int64, nodes []modelNode) bool {
+	work := make([]modelNode, len(nodes))
+	for i := range nodes {
+		capCopy := make(map[corev1.ResourceName]int64, len(nodes[i].cap))
+		for k, v := range nodes[i].cap {
+			capCopy[k] = v
+		}
+		work[i] = modelNode{cap: capCopy}
+	}
+
+	// Build replicas list: sets x oneSet
+	total := int(sets) * len(oneSet)
+	replicas := make([]map[corev1.ResourceName]int64, 0, total)
+	for i := int64(0); i < sets; i++ {
+		replicas = append(replicas, oneSet...)
+	}
+
+	// Sort replicas by a size heuristic (e.g. sum of demands), helps greedy packing
+	sort.Slice(replicas, func(i, j int) bool {
+		return demandScore(replicas[i]) > demandScore(replicas[j])
+	})
+
+	// Greedy first-fit
+	for _, r := range replicas {
+		placed := false
+		for i := range work {
+			if fitsAll(r, work[i].cap) {
+				consumeAll(r, work[i].cap)
+				placed = true
+				break
+			}
+		}
+		if !placed {
+			return false
+		}
+	}
+	return true
+}
+
+// demandScore is used to rank replicas in terms of their size and difficulty to schedule
+// Currently uses sum of values
+func demandScore(m map[corev1.ResourceName]int64) int64 {
+	var s int64
+	for _, v := range m {
+		if v > 0 {
+			s += v
+		}
+	}
+	return s
+}
+
+func fitsAll(demand map[corev1.ResourceName]int64, capacity map[corev1.ResourceName]int64) bool {
+	for k, req := range demand {
+		if req <= 0 {
+			continue
+		}
+		if capacity[k] < req {
+			return false
+		}
+	}
+	return true
+}
+
+func consumeAll(demand map[corev1.ResourceName]int64, capacity map[corev1.ResourceName]int64) {
+	for k, req := range demand {
+		if req <= 0 {
+			continue
+		}
+		capacity[k] -= req
+	}
 }
 
 // podsInSet computes the total number of pods in the CRD