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"
@@ -54,7 +55,7 @@ func (ge *GeneralEstimator) MaxAvailableReplicas(_ context.Context, clusters []*
 }
 
 func (ge *GeneralEstimator) maxAvailableReplicas(cluster *clusterv1alpha1.Cluster, replicaRequirements *workv1alpha2.ReplicaRequirements) int32 {
-	//Note: resourceSummary must be deep-copied before using in the function to avoid modifying the original data structure.
+	// Note: resourceSummary must be deep-copied before using in the function to avoid modifying the original data structure.
 	resourceSummary := cluster.Status.ResourceSummary.DeepCopy()
 	if resourceSummary == nil {
 		return 0
@@ -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,265 @@ 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
+// replica kinds (demand + count) and performs a first-fit-decreasing placement onto model-grade nodes.
+// `upperBound` caps the search. We can set 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
+	}
+
+	// Compressed one-set: per-kind (identical replicas grouped)
+	oneSetKinds := expandKindsOneSet(components)
+	if len(oneSetKinds) == 0 {
+		// No pods in a set -> nothing to schedule under models
+		return 0, nil
+	}
+
+	// Use cluster "available" totals (allocatable - allocated - allocating) for normalized scoring.
+	// This reflects what the cluster can actually accept *now*.
+	totals := availableResourceMap(cluster.Status.ResourceSummary)
+
+	// Binary search on #sets within [0, upperBound]
+	lo, hi := int64(0), upperBound
+	for lo < hi {
+		mid := (lo + hi + 1) / 2
+		if modelsFeasibleCompressed(mid, oneSetKinds, nodes, totals) {
+			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")
+	}
+
+	if len(cluster.Spec.ResourceModels) > 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))
+	}
+
+	// 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++ {
+		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
+}
+
+// replicaKind represents a single type of component, including replica demand and count
+type replicaKind struct {
+	dem   map[corev1.ResourceName]int64 // per-replica demand
+	count int64                         // how many replicas
+	score float64                       // ordering heuristic (higher first)
+}
+
+// expandKindsOneSet flattens components into a slice of unique replica kinds.
+// Each entry holds the per-replica demand and how many replicas of that kind a set needs.
+func expandKindsOneSet(components []workv1alpha2.Component) []replicaKind {
+	kinds := make([]replicaKind, 0, len(components))
+	for _, c := range components {
+		if c.ReplicaRequirements == nil || c.ReplicaRequirements.ResourceRequest == nil {
+			continue
+		}
+		// normalize per-replica demand
+		base := make(map[corev1.ResourceName]int64, len(c.ReplicaRequirements.ResourceRequest))
+		for name, qty := range c.ReplicaRequirements.ResourceRequest {
+			base[name] = quantityAsInt64(qty)
+		}
+		// skip zero-demand or non-positive replica count
+		if allZero(base) || c.Replicas <= 0 {
+			continue
+		}
+
+		k := replicaKind{
+			dem:   base,
+			count: int64(c.Replicas),
+			// score is filled later once we know cluster-wide totals
+		}
+		kinds = append(kinds, k)
+	}
+	return kinds
+}
+
+// modelsFeasibleCompressed checks if the given # of copies of `oneSetKinds` can be placed onto `nodes`
+// using first-fit decreasing but placing **batches** of identical replicas at once.
+// The ordering heuristic uses a normalized "max utilization ratio" to avoid unit bias.
+func modelsFeasibleCompressed(
+	sets int64,
+	oneSetKinds []replicaKind,
+	nodes []modelNode,
+	totals map[corev1.ResourceName]int64, // cluster-wide totals from ResourceSummary.Allocatable or "available"
+) bool {
+	if sets <= 0 {
+		return true
+	}
+	if len(oneSetKinds) == 0 {
+		return true
+	}
+
+	// working copy of node capacities
+	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}
+	}
+
+	// scale counts by #sets and compute normalized scores
+	items := make([]replicaKind, len(oneSetKinds))
+	for i, k := range oneSetKinds {
+		items[i] = replicaKind{
+			dem:   k.dem,
+			count: k.count * sets,
+		}
+		items[i].score = demandScoreNormalized(items[i].dem, totals)
+	}
+
+	// sort decreasing by normalized "max utilization ratio"
+	sort.Slice(items, func(i, j int) bool { return items[i].score > items[j].score })
+
+	// greedy first-fit with batch placement
+	for idx := range items {
+		if items[idx].count <= 0 {
+			continue
+		}
+		remaining := items[idx].count
+		for n := range work {
+			if remaining == 0 {
+				break
+			}
+			fit := maxFit(work[n].cap, items[idx].dem) // how many replicas of this kind fit on node n
+			if fit <= 0 {
+				continue
+			}
+			place := fit
+			if place > remaining {
+				place = remaining
+			}
+			consumeMul(work[n].cap, items[idx].dem, place)
+			remaining -= place
+		}
+		if remaining > 0 {
+			// couldn't place all replicas of this kind -> infeasible
+			return false
+		}
+	}
+	return true
+}
+
+// demandScoreNormalized returns the "max utilization ratio" of a demand vector against total capacities.
+// If a resource is missing/zero in total, treat it as maximally constrained.
+func demandScoreNormalized(
+	demand map[corev1.ResourceName]int64,
+	total map[corev1.ResourceName]int64,
+) float64 {
+	var maxRatio float64
+	for res, req := range demand {
+		if req <= 0 {
+			continue
+		}
+		totalCap := float64(total[res])
+		if totalCap <= 0 {
+			return math.MaxFloat64
+		}
+		ratio := float64(req) / totalCap
+		if ratio > maxRatio {
+			maxRatio = ratio
+		}
+	}
+	return maxRatio
+}
+
+// maxFit returns how many copies of `dem` fit in `cap` simultaneously.
+func maxFit(cap map[corev1.ResourceName]int64, dem map[corev1.ResourceName]int64) int64 {
+	var limit int64 = math.MaxInt64
+	for k, req := range dem {
+		if req <= 0 {
+			continue
+		}
+		avail := cap[k]
+		if avail <= 0 {
+			return 0
+		}
+		bound := avail / req
+		if bound < limit {
+			limit = bound
+		}
+	}
+	if limit == math.MaxInt64 {
+		return 0
+	}
+	return limit
+}
+
+// consumeMul subtracts `mult` * dem from cap.
+func consumeMul(cap map[corev1.ResourceName]int64, dem map[corev1.ResourceName]int64, mult int64) {
+	if mult <= 0 {
+		return
+	}
+	for k, req := range dem {
+		if req <= 0 {
+			continue
+		}
+		cap[k] -= req * mult
+	}
 }
 
 // podsInSet computes the total number of pods in the CRD