Avoid computing QOS multiple times

plugin/pkg/scheduler/algorithm/predicates/predicates.go

@@ -68,10 +68,17 @@ func (c *CachedNodeInfo) GetNodeInfo(id string) (*api.Node, error) {
 // podMetadata defines a type, that is an expected type that is passed
 // as metadata for predicate functions
 type predicateMetadata struct {
+	podBestEffort bool
 }
 
 func PredicateMetadata(pod *api.Pod) interface{} {
-	return &predicateMetadata{}
+	if pod == nil {
+		// We cannot compute metadata, just return nil
+		return nil
+	}
+	return &predicateMetadata{
+		podBestEffort: isPodBestEffort(pod),
+	}
 }
 
 func isVolumeConflict(volume api.Volume, pod *api.Pod) bool {
@@ -1060,8 +1067,18 @@ func CheckNodeMemoryPressurePredicate(pod *api.Pod, meta interface{}, nodeInfo *
 		return false, fmt.Errorf("node not found")
 	}
 
+	var podBestEffort bool
+
+	predicateMeta, ok := meta.(*predicateMetadata)
+	if ok {
+		podBestEffort = predicateMeta.podBestEffort
+	} else {
+		// We couldn't parse metadata - fallback to computing it.
+		podBestEffort = isPodBestEffort(pod)
+	}
+
 	// pod is not BestEffort pod
-	if !isPodBestEffort(pod) {
+	if !podBestEffort {
 		return true, nil
 	}
 

plugin/pkg/scheduler/factory/factory_test.go

@@ -116,11 +116,11 @@ func TestCreateFromEmptyConfig(t *testing.T) {
 	factory.CreateFromConfig(policy)
 }
 
-func PredicateOne(pod *api.Pod, nodeInfo *schedulercache.NodeInfo) (bool, error) {
+func PredicateOne(pod *api.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (bool, error) {
 	return true, nil
 }
 
-func PredicateTwo(pod *api.Pod, nodeInfo *schedulercache.NodeInfo) (bool, error) {
+func PredicateTwo(pod *api.Pod, meta interface{}, nodeInfo *schedulercache.NodeInfo) (bool, error) {
 	return true, nil
 }
 

plugin/pkg/scheduler/generic_scheduler.go

@@ -144,9 +144,10 @@ func findNodesThatFit(pod *api.Pod, nodeNameToInfo map[string]*schedulercache.No
 	} else {
 		predicateResultLock := sync.Mutex{}
 		errs := []error{}
+		meta := predicates.PredicateMetadata(pod)
 		checkNode := func(i int) {
 			nodeName := nodes.Items[i].Name
-			fits, failedPredicate, err := podFitsOnNode(pod, nodeNameToInfo[nodeName], predicateFuncs)
+			fits, failedPredicate, err := podFitsOnNode(pod, meta, nodeNameToInfo[nodeName], predicateFuncs)
 
 			predicateResultLock.Lock()
 			defer predicateResultLock.Unlock()
@@ -182,9 +183,9 @@ func findNodesThatFit(pod *api.Pod, nodeNameToInfo map[string]*schedulercache.No
 }
 
 // Checks whether node with a given name and NodeInfo satisfies all predicateFuncs.
-func podFitsOnNode(pod *api.Pod, info *schedulercache.NodeInfo, predicateFuncs map[string]algorithm.FitPredicate) (bool, string, error) {
+func podFitsOnNode(pod *api.Pod, meta interface{}, info *schedulercache.NodeInfo, predicateFuncs map[string]algorithm.FitPredicate) (bool, string, error) {
 	for _, predicate := range predicateFuncs {
-		fit, err := predicate(pod, nil, info)
+		fit, err := predicate(pod, meta, info)
 		if err != nil {
 			switch e := err.(type) {
 			case *predicates.InsufficientResourceError: