Move resource-based priority functions to their Score plugins

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

@@ -19,11 +19,12 @@ package noderesources
 import (
 	"context"
 	"fmt"
+	"math"
 
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/kubernetes/pkg/scheduler/algorithm/priorities"
-	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/migration"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/kubernetes/pkg/features"
 	framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
 )
 
@@ -31,6 +32,7 @@ import (
 // of capacity, and prioritizes the host based on how close the two metrics are to each other.
 type BalancedAllocation struct {
 	handle framework.FrameworkHandle
+	resourceAllocationScorer
 }
 
 var _ = framework.ScorePlugin(&BalancedAllocation{})
@@ -50,9 +52,14 @@ func (ba *BalancedAllocation) Score(ctx context.Context, state *framework.CycleS
 		return 0, framework.NewStatus(framework.Error, fmt.Sprintf("getting node %q from Snapshot: %v", nodeName, err))
 	}
 
-	// BalancedResourceAllocationMap does not use priority metadata, hence we pass nil here
-	s, err := priorities.BalancedResourceAllocationMap(pod, nil, nodeInfo)
-	return s.Score, migration.ErrorToFrameworkStatus(err)
+	// ba.score favors nodes with balanced resource usage rate.
+	// It should **NOT** be used alone, and **MUST** be used together
+	// with NodeResourcesLeastAllocated plugin. 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 = 10 - variance(cpuFraction,memoryFraction,volumeFraction)*10. 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)
 }
 
 // ScoreExtensions of the Score plugin.
@@ -62,5 +69,52 @@ func (ba *BalancedAllocation) ScoreExtensions() framework.ScoreExtensions {
 
 // NewBalancedAllocation initializes a new plugin and returns it.
 func NewBalancedAllocation(_ *runtime.Unknown, h framework.FrameworkHandle) (framework.Plugin, error) {
-	return &BalancedAllocation{handle: h}, nil
+	return &BalancedAllocation{
+		handle: h,
+		resourceAllocationScorer: resourceAllocationScorer{
+			BalancedAllocationName,
+			balancedResourceScorer,
+			DefaultRequestedRatioResources,
+		},
+	}, nil
+}
+
+// todo: use resource weights in the scorer function
+func balancedResourceScorer(requested, allocable resourceToValueMap, includeVolumes bool, requestedVolumes int, allocatableVolumes int) int64 {
+	cpuFraction := fractionOfCapacity(requested[v1.ResourceCPU], allocable[v1.ResourceCPU])
+	memoryFraction := fractionOfCapacity(requested[v1.ResourceMemory], allocable[v1.ResourceMemory])
+	// This to find a node which has most balanced CPU, memory and volume usage.
+	if cpuFraction >= 1 || memoryFraction >= 1 {
+		// if requested >= capacity, the corresponding host should never be preferred.
+		return 0
+	}
+
+	if includeVolumes && utilfeature.DefaultFeatureGate.Enabled(features.BalanceAttachedNodeVolumes) && allocatableVolumes > 0 {
+		volumeFraction := float64(requestedVolumes) / float64(allocatableVolumes)
+		if volumeFraction >= 1 {
+			// if requested >= capacity, the corresponding host should never be preferred.
+			return 0
+		}
+		// Compute variance for all the three fractions.
+		mean := (cpuFraction + memoryFraction + volumeFraction) / float64(3)
+		variance := float64((((cpuFraction - mean) * (cpuFraction - mean)) + ((memoryFraction - mean) * (memoryFraction - mean)) + ((volumeFraction - mean) * (volumeFraction - mean))) / float64(3))
+		// Since the variance is between positive fractions, it will be positive fraction. 1-variance lets the
+		// score to be higher for node which has least variance and multiplying it with 10 provides the scaling
+		// factor needed.
+		return int64((1 - variance) * float64(framework.MaxNodeScore))
+	}
+
+	// Upper and lower boundary of difference between cpuFraction and memoryFraction are -1 and 1
+	// respectively. Multiplying the absolute value of the difference by 10 scales the value to
+	// 0-10 with 0 representing well balanced allocation and 10 poorly balanced. Subtracting it from
+	// 10 leads to the score which also scales from 0 to 10 while 10 representing well balanced.
+	diff := math.Abs(cpuFraction - memoryFraction)
+	return int64((1 - diff) * float64(framework.MaxNodeScore))
+}
+
+func fractionOfCapacity(requested, capacity int64) float64 {
+	if capacity == 0 {
+		return 1
+	}
+	return float64(requested) / float64(capacity)
 }