Extent the NodeResourcesBalancedAllocation plugin to cover more resources

Signed-off-by: Dave Chen <dave.chen@arm.com>

pkg/scheduler/framework/plugins/noderesources/balanced_allocation.go

@@ -23,6 +23,8 @@ import (
 
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/kubernetes/pkg/scheduler/apis/config"
+	"k8s.io/kubernetes/pkg/scheduler/apis/config/validation"
 	"k8s.io/kubernetes/pkg/scheduler/framework"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/names"
@@ -53,11 +55,10 @@ func (ba *BalancedAllocation) Score(ctx context.Context, state *framework.CycleS
 	}
 
 	// ba.score favors nodes with balanced resource usage rate.
-	// It calculates the difference between the cpu and memory fraction of capacity,
-	// and prioritizes the host based on how close the two metrics are to each other.
-	// Detail: score = (1 - variance(cpuFraction,memoryFraction,volumeFraction)) * MaxNodeScore. The algorithm is partly inspired by:
-	// "Wei Huang et al. An Energy Efficient Virtual Machine Placement Algorithm with Balanced
-	// Resource Utilization"
+	// It calculates the standard deviation for those resources and prioritizes the node based on how close the usage of those resources is to each other.
+	// Detail: score = (1 - std) * MaxNodeScore, where std is calculated by the root square of Σ((fraction(i)-mean)^2)/len(resources)
+	// The algorithm is partly inspired by:
+	// "Wei Huang et al. An Energy Efficient Virtual Machine Placement Algorithm with Balanced Resource Utilization"
 	return ba.score(pod, nodeInfo)
 }
 
@@ -67,42 +68,63 @@ func (ba *BalancedAllocation) ScoreExtensions() framework.ScoreExtensions {
 }
 
 // NewBalancedAllocation initializes a new plugin and returns it.
-func NewBalancedAllocation(_ runtime.Object, h framework.Handle, fts feature.Features) (framework.Plugin, error) {
+func NewBalancedAllocation(baArgs runtime.Object, h framework.Handle, fts feature.Features) (framework.Plugin, error) {
+	args, ok := baArgs.(*config.NodeResourcesBalancedAllocationArgs)
+	if !ok {
+		return nil, fmt.Errorf("want args to be of type NodeResourcesBalancedAllocationArgs, got %T", baArgs)
+	}
+
+	if err := validation.ValidateNodeResourcesBalancedAllocationArgs(nil, args); err != nil {
+		return nil, err
+	}
+
+	resToWeightMap := make(resourceToWeightMap)
+
+	for _, resource := range args.Resources {
+		resToWeightMap[v1.ResourceName(resource.Name)] = resource.Weight
+	}
+
 	return &BalancedAllocation{
 		handle: h,
 		resourceAllocationScorer: resourceAllocationScorer{
 			Name:                BalancedAllocationName,
 			scorer:              balancedResourceScorer,
-			resourceToWeightMap: defaultRequestedRatioResources,
+			resourceToWeightMap: resToWeightMap,
 			enablePodOverhead:   fts.EnablePodOverhead,
 		},
 	}, nil
 }
 
-// todo: use resource weights in the scorer function
 func balancedResourceScorer(requested, allocable resourceToValueMap) int64 {
-	cpuFraction := fractionOfCapacity(requested[v1.ResourceCPU], allocable[v1.ResourceCPU])
-	memoryFraction := fractionOfCapacity(requested[v1.ResourceMemory], allocable[v1.ResourceMemory])
-	// fractions might be greater than 1 because pods with no requests get minimum
-	// values.
-	if cpuFraction > 1 {
-		cpuFraction = 1
-	}
-	if memoryFraction > 1 {
-		memoryFraction = 1
+	var resourceToFractions []float64
+	var totalFraction float64
+	for name, value := range requested {
+		fraction := float64(value) / float64(allocable[name])
+		if fraction > 1 {
+			fraction = 1
+		}
+		totalFraction += fraction
+		resourceToFractions = append(resourceToFractions, fraction)
 	}
 
-	// Upper and lower boundary of difference between cpuFraction and memoryFraction are -1 and 1
-	// respectively. Multiplying the absolute value of the difference by `MaxNodeScore` scales the value to
-	// 0-MaxNodeScore with 0 representing well balanced allocation and `MaxNodeScore` poorly balanced. Subtracting it from
-	// `MaxNodeScore` leads to the score which also scales from 0 to `MaxNodeScore` while `MaxNodeScore` representing well balanced.
-	diff := math.Abs(cpuFraction - memoryFraction)
-	return int64((1 - diff) * float64(framework.MaxNodeScore))
-}
+	std := 0.0
 
-func fractionOfCapacity(requested, capacity int64) float64 {
-	if capacity == 0 {
-		return 1
+	// For most cases, resources are limited to cpu and memory, the std could be simplified to std := (fraction1-fraction2)/2
+	// len(fractions) > 2: calculate std based on the well-known formula - root square of Σ((fraction(i)-mean)^2)/len(fractions)
+	// Otherwise, set the std to zero is enough.
+	if len(resourceToFractions) == 2 {
+		std = math.Abs((resourceToFractions[0] - resourceToFractions[1]) / 2)
+
+	} else if len(resourceToFractions) > 2 {
+		mean := totalFraction / float64(len(resourceToFractions))
+		var sum float64
+		for _, fraction := range resourceToFractions {
+			sum = sum + (fraction-mean)*(fraction-mean)
+		}
+		std = math.Sqrt(sum / float64(len(resourceToFractions)))
 	}
-	return float64(requested) / float64(capacity)
+
+	// STD (standard deviation) is always a positive value. 1-deviation lets the score to be higher for node which has least deviation and
+	// multiplying it with `MaxNodeScore` provides the scaling factor needed.
+	return int64((1 - std) * float64(framework.MaxNodeScore))
 }