koord-scheduler: support node cpu amplification

Signed-off-by: Zach Zhu <[email protected]>

.licenseignore

@@ -4,6 +4,8 @@ pkg/descheduler/controllers/migration/controllerfinder
 pkg/scheduler/plugins/coscheduling
 pkg/scheduler/plugins/nodenumaresource/least_allocated.go
 pkg/scheduler/plugins/nodenumaresource/most_allocated.go
+pkg/scheduler/plugins/nodecpuamplification/least_allocated.go
+pkg/scheduler/plugins/nodecpuamplification/most_allocated.go
 pkg/scheduler/frameworkext/topologymanager/policy.go
 pkg/scheduler/frameworkext/topologymanager/policy_test.go
 pkg/scheduler/frameworkext/topologymanager/policy_best_effort.go

cmd/koord-scheduler/main.go

@@ -30,6 +30,7 @@ import (
 	"github.com/koordinator-sh/koordinator/pkg/scheduler/plugins/deviceshare"
 	"github.com/koordinator-sh/koordinator/pkg/scheduler/plugins/elasticquota"
 	"github.com/koordinator-sh/koordinator/pkg/scheduler/plugins/loadaware"
+	"github.com/koordinator-sh/koordinator/pkg/scheduler/plugins/nodecpuamplification"
 	"github.com/koordinator-sh/koordinator/pkg/scheduler/plugins/nodenumaresource"
 	"github.com/koordinator-sh/koordinator/pkg/scheduler/plugins/reservation"
 
@@ -40,13 +41,14 @@ import (
 )
 
 var koordinatorPlugins = map[string]frameworkruntime.PluginFactory{
-	loadaware.Name:        loadaware.New,
-	nodenumaresource.Name: nodenumaresource.New,
-	reservation.Name:      reservation.New,
-	coscheduling.Name:     coscheduling.New,
-	deviceshare.Name:      deviceshare.New,
-	elasticquota.Name:     elasticquota.New,
-	defaultprebind.Name:   defaultprebind.New,
+	loadaware.Name:            loadaware.New,
+	nodenumaresource.Name:     nodenumaresource.New,
+	reservation.Name:          reservation.New,
+	coscheduling.Name:         coscheduling.New,
+	deviceshare.Name:          deviceshare.New,
+	elasticquota.Name:         elasticquota.New,
+	defaultprebind.Name:       defaultprebind.New,
+	nodecpuamplification.Name: nodecpuamplification.New,
 }
 
 func flatten(plugins map[string]frameworkruntime.PluginFactory) []app.Option {

pkg/scheduler/apis/config/types.go

@@ -210,3 +210,13 @@ type DeviceShareArgs struct {
 	// ScoringStrategy selects the device resource scoring strategy.
 	ScoringStrategy *ScoringStrategy
 }
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// NodeCPUAmplificationArgs defines the parameters for NodeCPUAmplification plugin.
+type NodeCPUAmplificationArgs struct {
+	metav1.TypeMeta
+
+	// ScoringStrategy selects the normalized node resource scoring strategy.
+	ScoringStrategy *ScoringStrategy
+}

pkg/scheduler/apis/config/v1beta2/defaults.go

@@ -37,6 +37,11 @@ var (
 		corev1.ResourceMemory: 1,
 	}
 
+	defaultResourceSpec = []schedconfigv1beta2.ResourceSpec{
+		{Name: string(corev1.ResourceCPU), Weight: 1},
+		{Name: string(corev1.ResourceMemory), Weight: 1},
+	}
+
 	defaultUsageThresholds = map[corev1.ResourceName]int64{
 		corev1.ResourceCPU:    65, // 65%
 		corev1.ResourceMemory: 95, // 95%
@@ -187,3 +192,22 @@ func SetDefaults_DeviceShareArgs(obj *DeviceShareArgs) {
 		}
 	}
 }
+
+func SetDefaults_NodeCPUAmplificationArgs(obj *NodeCPUAmplificationArgs) {
+	if obj.ScoringStrategy == nil {
+		obj.ScoringStrategy = &ScoringStrategy{
+			// By default, LeastAllocate is used to ensure high availability of applications
+			Type:      LeastAllocated,
+			Resources: defaultResourceSpec,
+		}
+	}
+	if len(obj.ScoringStrategy.Resources) == 0 {
+		// If no resources specified, use the default set.
+		obj.ScoringStrategy.Resources = append(obj.ScoringStrategy.Resources, defaultResourceSpec...)
+	}
+	for i := range obj.ScoringStrategy.Resources {
+		if obj.ScoringStrategy.Resources[i].Weight == 0 {
+			obj.ScoringStrategy.Resources[i].Weight = 1
+		}
+	}
+}

pkg/scheduler/apis/config/v1beta2/types.go

@@ -205,3 +205,13 @@ type DeviceShareArgs struct {
 	// ScoringStrategy selects the device resource scoring strategy.
 	ScoringStrategy *ScoringStrategy `json:"scoringStrategy,omitempty"`
 }
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// NodeCPUAmplificationArgs defines the parameters for NodeCPUAmplification plugin.
+type NodeCPUAmplificationArgs struct {
+	metav1.TypeMeta
+
+	// ScoringStrategy selects the normalized node resource scoring strategy.
+	ScoringStrategy *ScoringStrategy `json:"scoringStrategy,omitempty"`
+}

pkg/scheduler/apis/config/validation/validation_pluginargs.go

@@ -170,3 +170,15 @@ func ValidateNodeNUMAResourceArgs(path *field.Path, args *config.NodeNUMAResourc
 	}
 	return allErrs.ToAggregate()
 }
+
+func ValidateNodeCPUAmplificationArgs(path *field.Path, args *config.NodeCPUAmplificationArgs) error {
+	var allErrs field.ErrorList
+	if args.ScoringStrategy != nil {
+		allErrs = append(allErrs, validateResources(args.ScoringStrategy.Resources, path.Child("resources"))...)
+	}
+
+	if len(allErrs) == 0 {
+		return nil
+	}
+	return allErrs.ToAggregate()
+}

pkg/scheduler/plugins/nodecpuamplification/least_allocated.go

@@ -0,0 +1,57 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package nodecpuamplification
+
+import (
+	"k8s.io/kubernetes/pkg/scheduler/framework"
+)
+
+// leastResourceScorer favors nodes with fewer requested resources.
+// It calculates the percentage of memory, CPU and other resources requested by pods scheduled on the node, and
+// prioritizes based on the minimum of the average of the fraction of requested to capacity.
+//
+// Details:
+// (cpu((capacity-requested)*MaxNodeScore*cpuWeight/capacity) + memory((capacity-requested)*MaxNodeScore*memoryWeight/capacity) + ...)/weightSum
+func leastResourceScorer(resToWeightMap resourceToWeightMap) func(requested, allocatable resourceToValueMap) int64 {
+	return func(requested, allocatable resourceToValueMap) int64 {
+		var nodeScore, weightSum int64
+		for resource := range requested {
+			weight := resToWeightMap[resource]
+			resourceScore := leastRequestedScore(requested[resource], allocatable[resource])
+			nodeScore += resourceScore * weight
+			weightSum += weight
+		}
+		if weightSum == 0 {
+			return 0
+		}
+		return nodeScore / weightSum
+	}
+}
+
+// The unused capacity is calculated on a scale of 0-MaxNodeScore
+// 0 being the lowest priority and `MaxNodeScore` being the highest.
+// The more unused resources the higher the score is.
+func leastRequestedScore(requested, capacity int64) int64 {
+	if capacity == 0 {
+		return 0
+	}
+	if requested > capacity {
+		return 0
+	}
+
+	return ((capacity - requested) * framework.MaxNodeScore) / capacity
+}