nrt: score: introduce and use scoreInfo

similarly to what we did for filter, add a helper struct
to group together all the context we need to carry in the
internal implementation functions.
The goals are to streamline the existing code, to
reduce redundant call and to make room for more
arguments to be passed through, like the topology manager
configuration.

Signed-off-by: Francesco Romani <[email protected]>

Author: ffromani

pkg/noderesourcetopology/least_numa.go

@@ -18,12 +18,10 @@ package noderesourcetopology
 
 import (
 	v1 "k8s.io/api/core/v1"
-	v1qos "k8s.io/kubernetes/pkg/apis/core/v1/helper/qos"
 	"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
 	"k8s.io/kubernetes/pkg/scheduler/framework"
 
 	"github.com/go-logr/logr"
-	topologyv1alpha2 "github.com/k8stopologyawareschedwg/noderesourcetopology-api/pkg/apis/topology/v1alpha2"
 	"gonum.org/v1/gonum/stat/combin"
 
 	"sigs.k8s.io/scheduler-plugins/pkg/util"
@@ -34,20 +32,17 @@ const (
 	maxDistanceValue = 255
 )
 
-func leastNUMAContainerScopeScore(lh logr.Logger, pod *v1.Pod, zones topologyv1alpha2.ZoneList) (int64, *framework.Status) {
-	nodes := createNUMANodeList(lh, zones)
-	qos := v1qos.GetPodQOS(pod)
-
+func leastNUMAContainerScopeScore(lh logr.Logger, pod *v1.Pod, info *scoreInfo) (int64, *framework.Status) {
 	maxNUMANodesCount := 0
 	allContainersMinAvgDistance := true
 	// the order how TopologyManager asks for hint is important so doing it in the same order
 	// https://github.com/kubernetes/kubernetes/blob/master/pkg/kubelet/cm/topologymanager/scope_container.go#L52
 	for _, container := range append(pod.Spec.InitContainers, pod.Spec.Containers...) {
 		// if a container requests only non NUMA just continue
-		if onlyNonNUMAResources(nodes, container.Resources.Requests) {
+		if onlyNonNUMAResources(info.numaNodes, container.Resources.Requests) {
 			continue
 		}
-		numaNodes, isMinAvgDistance := numaNodesRequired(lh, qos, nodes, container.Resources.Requests)
+		numaNodes, isMinAvgDistance := numaNodesRequired(lh, info.qos, info.numaNodes, container.Resources.Requests)
 		// container's resources can't fit onto node, return MinNodeScore for whole pod
 		if numaNodes == nil {
 			// score plugin should be running after resource filter plugin so we should always find sufficient amount of NUMA nodes
@@ -65,7 +60,7 @@ func leastNUMAContainerScopeScore(lh logr.Logger, pod *v1.Pod, zones topologyv1a
 
 		// subtract the resources requested by the container from the given NUMA.
 		// this is necessary, so we won't allocate the same resources for the upcoming containers
-		subtractFromNUMAs(container.Resources.Requests, nodes, numaNodes.GetBits()...)
+		subtractFromNUMAs(container.Resources.Requests, info.numaNodes, numaNodes.GetBits()...)
 	}
 
 	if maxNUMANodesCount == 0 {
@@ -75,17 +70,14 @@ func leastNUMAContainerScopeScore(lh logr.Logger, pod *v1.Pod, zones topologyv1a
 	return normalizeScore(maxNUMANodesCount, allContainersMinAvgDistance), nil
 }
 
-func leastNUMAPodScopeScore(lh logr.Logger, pod *v1.Pod, zones topologyv1alpha2.ZoneList) (int64, *framework.Status) {
-	nodes := createNUMANodeList(lh, zones)
-	qos := v1qos.GetPodQOS(pod)
-
+func leastNUMAPodScopeScore(lh logr.Logger, pod *v1.Pod, info *scoreInfo) (int64, *framework.Status) {
 	resources := util.GetPodEffectiveRequest(pod)
 	// if a pod requests only non NUMA resources return max score
-	if onlyNonNUMAResources(nodes, resources) {
+	if onlyNonNUMAResources(info.numaNodes, resources) {
 		return framework.MaxNodeScore, nil
 	}
 
-	numaNodes, isMinAvgDistance := numaNodesRequired(lh, qos, nodes, resources)
+	numaNodes, isMinAvgDistance := numaNodesRequired(lh, info.qos, info.numaNodes, resources)
 	// pod's resources can't fit onto node, return MinNodeScore
 	if numaNodes == nil {
 		// score plugin should be running after resource filter plugin so we should always find sufficient amount of NUMA nodes

pkg/noderesourcetopology/plugin.go

@@ -58,7 +58,14 @@ type filterInfo struct {
 }
 
 type filterFn func(logr.Logger, *v1.Pod, *filterInfo) *framework.Status
-type scoringFn func(logr.Logger, *v1.Pod, topologyv1alpha2.ZoneList) (int64, *framework.Status)
+
+type scoreInfo struct {
+	topologyManager nodeconfig.TopologyManager
+	qos             v1.PodQOSClass
+	numaNodes       NUMANodeList
+}
+
+type scoringFn func(logr.Logger, *v1.Pod, *scoreInfo) (int64, *framework.Status)
 
 // TopologyMatch plugin which run simplified version of TopologyManager's admit handler
 type TopologyMatch struct {

pkg/noderesourcetopology/score.go

@@ -30,7 +30,6 @@ import (
 	apiconfig "sigs.k8s.io/scheduler-plugins/apis/config"
 
 	"github.com/go-logr/logr"
-	topologyv1alpha2 "github.com/k8stopologyawareschedwg/noderesourcetopology-api/pkg/apis/topology/v1alpha2"
 	"sigs.k8s.io/scheduler-plugins/pkg/noderesourcetopology/logging"
 	"sigs.k8s.io/scheduler-plugins/pkg/noderesourcetopology/nodeconfig"
 	"sigs.k8s.io/scheduler-plugins/pkg/noderesourcetopology/stringify"
@@ -70,7 +69,8 @@ func (tm *TopologyMatch) Score(ctx context.Context, state *framework.CycleState,
 
 	lh.V(6).Info("scoring node")
 	// if it's a non-guaranteed pod, every node is considered to be a good fit
-	if v1qos.GetPodQOS(pod) != v1.PodQOSGuaranteed {
+	qos := v1qos.GetPodQOS(pod)
+	if qos != v1.PodQOSGuaranteed {
 		return framework.MaxNodeScore, nil
 	}
 
@@ -87,11 +87,18 @@ func (tm *TopologyMatch) Score(ctx context.Context, state *framework.CycleState,
 
 	lh.V(6).Info("found object", "noderesourcetopology", stringify.NodeResourceTopologyResources(nodeTopology))
 
-	handler := tm.scoringHandlerFromTopologyManagerConfig(nodeconfig.TopologyManagerFromNodeResourceTopology(lh, nodeTopology))
+	conf := nodeconfig.TopologyManagerFromNodeResourceTopology(lh, nodeTopology)
+	handler := tm.scoringHandlerFromTopologyManagerConfig(conf)
 	if handler == nil {
 		return 0, nil
 	}
-	return handler(lh, pod, nodeTopology.Zones)
+	numaNodes := createNUMANodeList(lh, nodeTopology.Zones)
+	si := scoreInfo{
+		topologyManager: conf,
+		qos:             qos,
+		numaNodes:       numaNodes,
+	}
+	return handler(lh, pod, &si)
 }
 
 func (tm *TopologyMatch) ScoreExtensions() framework.ScoreExtensions {
@@ -132,27 +139,24 @@ func getScoringStrategyFunction(strategy apiconfig.ScoringStrategyType) (scoreSt
 	}
 }
 
-func podScopeScore(lh logr.Logger, pod *v1.Pod, zones topologyv1alpha2.ZoneList, scorerFn scoreStrategyFn, resourceToWeightMap resourceToWeightMap) (int64, *framework.Status) {
+func podScopeScore(lh logr.Logger, pod *v1.Pod, info *scoreInfo, scorerFn scoreStrategyFn, resourceToWeightMap resourceToWeightMap) (int64, *framework.Status) {
 	// This code is in Admit implementation of pod scope
 	// https://github.com/kubernetes/kubernetes/blob/9ff3b7e744b34c099c1405d9add192adbef0b6b1/pkg/kubelet/cm/topologymanager/scope_pod.go#L52
 	// but it works with HintProviders, takes into account all possible allocations.
 	resources := util.GetPodEffectiveRequest(pod)
-
-	allocatablePerNUMA := createNUMANodeList(lh, zones)
-	finalScore := scoreForEachNUMANode(lh, resources, allocatablePerNUMA, scorerFn, resourceToWeightMap)
+	finalScore := scoreForEachNUMANode(lh, resources, info.numaNodes, scorerFn, resourceToWeightMap)
 	lh.V(2).Info("pod scope scoring final node score", "finalScore", finalScore)
 	return finalScore, nil
 }
 
-func containerScopeScore(lh logr.Logger, pod *v1.Pod, zones topologyv1alpha2.ZoneList, scorerFn scoreStrategyFn, resourceToWeightMap resourceToWeightMap) (int64, *framework.Status) {
+func containerScopeScore(lh logr.Logger, pod *v1.Pod, info *scoreInfo, scorerFn scoreStrategyFn, resourceToWeightMap resourceToWeightMap) (int64, *framework.Status) {
 	// This code is in Admit implementation of container scope
 	// https://github.com/kubernetes/kubernetes/blob/9ff3b7e744b34c099c1405d9add192adbef0b6b1/pkg/kubelet/cm/topologymanager/scope_container.go#L52
 	containers := append(pod.Spec.InitContainers, pod.Spec.Containers...)
 	contScore := make([]float64, len(containers))
-	allocatablePerNUMA := createNUMANodeList(lh, zones)
 
 	for i, container := range containers {
-		contScore[i] = float64(scoreForEachNUMANode(lh, container.Resources.Requests, allocatablePerNUMA, scorerFn, resourceToWeightMap))
+		contScore[i] = float64(scoreForEachNUMANode(lh, container.Resources.Requests, info.numaNodes, scorerFn, resourceToWeightMap))
 		lh.V(6).Info("container scope scoring", "container", container.Name, "score", contScore[i])
 	}
 	finalScore := int64(stat.Mean(contScore, nil))
@@ -174,13 +178,13 @@ func (tm *TopologyMatch) scoringHandlerFromTopologyManagerConfig(conf nodeconfig
 		return nil
 	}
 	if conf.Scope == kubeletconfig.PodTopologyManagerScope {
-		return func(lh logr.Logger, pod *v1.Pod, zones topologyv1alpha2.ZoneList) (int64, *framework.Status) {
-			return podScopeScore(lh, pod, zones, tm.scoreStrategyFunc, tm.resourceToWeightMap)
+		return func(lh logr.Logger, pod *v1.Pod, info *scoreInfo) (int64, *framework.Status) {
+			return podScopeScore(lh, pod, info, tm.scoreStrategyFunc, tm.resourceToWeightMap)
 		}
 	}
 	if conf.Scope == kubeletconfig.ContainerTopologyManagerScope {
-		return func(lh logr.Logger, pod *v1.Pod, zones topologyv1alpha2.ZoneList) (int64, *framework.Status) {
-			return containerScopeScore(lh, pod, zones, tm.scoreStrategyFunc, tm.resourceToWeightMap)
+		return func(lh logr.Logger, pod *v1.Pod, info *scoreInfo) (int64, *framework.Status) {
+			return containerScopeScore(lh, pod, info, tm.scoreStrategyFunc, tm.resourceToWeightMap)
 		}
 	}
 	return nil // cannot happen