Merge pull request #86175 from ahg-g/ahg1-prefilters

Wrap InterPodAffinity predicate metadata as a Prefilter

pkg/scheduler/algorithm/predicates/metadata.go

@@ -179,7 +179,8 @@ func (m *serviceAffinityMetadata) clone() *serviceAffinityMetadata {
 	return &copy
 }
 
-type podAffinityMetadata struct {
+// PodAffinityMetadata pre-computed state for inter-pod affinity predicate.
+type PodAffinityMetadata struct {
 	// A map of topology pairs to the number of existing pods that has anti-affinity terms that match the "pod".
 	topologyToMatchedExistingAntiAffinityTerms topologyToMatchedTermCount
 	// A map of topology pairs to the number of existing pods that match the affinity terms of the "pod".
@@ -225,7 +226,8 @@ func (m topologyToMatchedTermCount) updateWithAntiAffinityTerms(targetPod *v1.Po
 	}
 }
 
-func (m *podAffinityMetadata) updatePod(updatedPod, pod *v1.Pod, node *v1.Node, multiplier int64) error {
+// UpdateWithPod updates the metadata counters with the (anti)affinity matches for the given pod.
+func (m *PodAffinityMetadata) UpdateWithPod(updatedPod, pod *v1.Pod, node *v1.Node, multiplier int64) error {
 	if m == nil {
 		return nil
 	}
@@ -265,12 +267,13 @@ func (m *podAffinityMetadata) updatePod(updatedPod, pod *v1.Pod, node *v1.Node,
 	return nil
 }
 
-func (m *podAffinityMetadata) clone() *podAffinityMetadata {
+// Clone makes a deep copy of PodAffinityMetadata.
+func (m *PodAffinityMetadata) Clone() *PodAffinityMetadata {
 	if m == nil {
 		return nil
 	}
 
-	copy := podAffinityMetadata{}
+	copy := PodAffinityMetadata{}
 	copy.topologyToMatchedAffinityTerms = m.topologyToMatchedAffinityTerms.clone()
 	copy.topologyToMatchedAntiAffinityTerms = m.topologyToMatchedAntiAffinityTerms.clone()
 	copy.topologyToMatchedExistingAntiAffinityTerms = m.topologyToMatchedExistingAntiAffinityTerms.clone()
@@ -327,7 +330,6 @@ type predicateMetadata struct {
 	evenPodsSpreadMetadata *evenPodsSpreadMetadata
 
 	serviceAffinityMetadata  *serviceAffinityMetadata
-	podAffinityMetadata      *podAffinityMetadata
 	podFitsResourcesMetadata *podFitsResourcesMetadata
 	podFitsHostPortsMetadata *podFitsHostPortsMetadata
 }
@@ -373,7 +375,6 @@ func (f *MetadataProducerFactory) GetPredicateMetadata(pod *v1.Pod, sharedLister
 	}
 
 	var allNodes []*schedulernodeinfo.NodeInfo
-	var havePodsWithAffinityNodes []*schedulernodeinfo.NodeInfo
 	if sharedLister != nil {
 		var err error
 		allNodes, err = sharedLister.NodeInfos().List()
@@ -381,12 +382,6 @@ func (f *MetadataProducerFactory) GetPredicateMetadata(pod *v1.Pod, sharedLister
 			klog.Errorf("failed to list NodeInfos: %v", err)
 			return nil
 		}
-		havePodsWithAffinityNodes, err = sharedLister.NodeInfos().HavePodsWithAffinityList()
-		if err != nil {
-			klog.Errorf("failed to list NodeInfos: %v", err)
-			return nil
-		}
-
 	}
 
 	// evenPodsSpreadMetadata represents how existing pods match "pod"
@@ -397,16 +392,9 @@ func (f *MetadataProducerFactory) GetPredicateMetadata(pod *v1.Pod, sharedLister
 		return nil
 	}
 
-	podAffinityMetadata, err := getPodAffinityMetadata(pod, allNodes, havePodsWithAffinityNodes)
-	if err != nil {
-		klog.Errorf("Error calculating podAffinityMetadata: %v", err)
-		return nil
-	}
-
 	predicateMetadata := &predicateMetadata{
 		pod:                      pod,
 		evenPodsSpreadMetadata:   evenPodsSpreadMetadata,
-		podAffinityMetadata:      podAffinityMetadata,
 		podFitsResourcesMetadata: getPodFitsResourcesMetedata(pod),
 		podFitsHostPortsMetadata: getPodFitsHostPortsMetadata(pod),
 	}
@@ -429,7 +417,8 @@ func getPodFitsResourcesMetedata(pod *v1.Pod) *podFitsResourcesMetadata {
 	}
 }
 
-func getPodAffinityMetadata(pod *v1.Pod, allNodes []*schedulernodeinfo.NodeInfo, havePodsWithAffinityNodes []*schedulernodeinfo.NodeInfo) (*podAffinityMetadata, error) {
+// GetPodAffinityMetadata computes inter-pod affinity metadata.
+func GetPodAffinityMetadata(pod *v1.Pod, allNodes []*schedulernodeinfo.NodeInfo, havePodsWithAffinityNodes []*schedulernodeinfo.NodeInfo) (*PodAffinityMetadata, error) {
 	// existingPodAntiAffinityMap will be used later for efficient check on existing pods' anti-affinity
 	existingPodAntiAffinityMap, err := getTPMapMatchingExistingAntiAffinity(pod, havePodsWithAffinityNodes)
 	if err != nil {
@@ -442,7 +431,7 @@ func getPodAffinityMetadata(pod *v1.Pod, allNodes []*schedulernodeinfo.NodeInfo,
 		return nil, err
 	}
 
-	return &podAffinityMetadata{
+	return &PodAffinityMetadata{
 		topologyToMatchedAffinityTerms:             incomingPodAffinityMap,
 		topologyToMatchedAntiAffinityTerms:         incomingPodAntiAffinityMap,
 		topologyToMatchedExistingAntiAffinityTerms: existingPodAntiAffinityMap,
@@ -619,7 +608,6 @@ func (meta *predicateMetadata) RemovePod(deletedPod *v1.Pod, node *v1.Node) erro
 	if deletedPodFullName == schedutil.GetPodFullName(meta.pod) {
 		return fmt.Errorf("deletedPod and meta.pod must not be the same")
 	}
-	meta.podAffinityMetadata.updatePod(deletedPod, meta.pod, node, -1)
 	meta.evenPodsSpreadMetadata.removePod(deletedPod, meta.pod, node)
 	meta.serviceAffinityMetadata.removePod(deletedPod, node)
 
@@ -637,9 +625,6 @@ func (meta *predicateMetadata) AddPod(addedPod *v1.Pod, node *v1.Node) error {
 		return fmt.Errorf("node not found")
 	}
 
-	if err := meta.podAffinityMetadata.updatePod(addedPod, meta.pod, node, 1); err != nil {
-		return err
-	}
 	// Update meta.evenPodsSpreadMetadata if meta.pod has hard spread constraints
 	// and addedPod matches that
 	meta.evenPodsSpreadMetadata.addPod(addedPod, meta.pod, node)
@@ -657,7 +642,6 @@ func (meta *predicateMetadata) ShallowCopy() Metadata {
 		podBestEffort: meta.podBestEffort,
 	}
 	newPredMeta.podFitsHostPortsMetadata = meta.podFitsHostPortsMetadata.clone()
-	newPredMeta.podAffinityMetadata = meta.podAffinityMetadata.clone()
 	newPredMeta.evenPodsSpreadMetadata = meta.evenPodsSpreadMetadata.clone()
 	newPredMeta.serviceAffinityMetadata = meta.serviceAffinityMetadata.clone()
 	newPredMeta.podFitsResourcesMetadata = meta.podFitsResourcesMetadata.clone()

pkg/scheduler/algorithm/predicates/metadata_test.go

@@ -70,16 +70,7 @@ func predicateMetadataEquivalent(meta1, meta2 *predicateMetadata) error {
 	for !reflect.DeepEqual(meta1.podFitsHostPortsMetadata.podPorts, meta2.podFitsHostPortsMetadata.podPorts) {
 		return fmt.Errorf("podPorts are not equal")
 	}
-	if !reflect.DeepEqual(meta1.podAffinityMetadata.topologyToMatchedAffinityTerms, meta2.podAffinityMetadata.topologyToMatchedAffinityTerms) {
+
-		return fmt.Errorf("topologyToMatchedAffinityTerms are not equal")
-	}
-	if !reflect.DeepEqual(meta1.podAffinityMetadata.topologyToMatchedAntiAffinityTerms, meta2.podAffinityMetadata.topologyToMatchedAntiAffinityTerms) {
-		return fmt.Errorf("topologyToMatchedAntiAffinityTerms are not equal")
-	}
-	if !reflect.DeepEqual(meta1.podAffinityMetadata.topologyToMatchedExistingAntiAffinityTerms,
-		meta2.podAffinityMetadata.topologyToMatchedExistingAntiAffinityTerms) {
-		return fmt.Errorf("topologyToMatchedExistingAntiAffinityTerms are not equal, got: %v, want: %v", meta1.podAffinityMetadata.topologyToMatchedExistingAntiAffinityTerms, meta2.podAffinityMetadata.topologyToMatchedExistingAntiAffinityTerms)
-	}
 	if meta1.serviceAffinityMetadata != nil {
 		sortablePods1 := sortablePods(meta1.serviceAffinityMetadata.matchingPodList)
 		sort.Sort(sortablePods1)
@@ -114,78 +105,6 @@ func TestPredicateMetadata_AddRemovePod(t *testing.T) {
 		"zone":   "z21",
 	}
 	selector1 := map[string]string{"foo": "bar"}
-	antiAffinityFooBar := &v1.PodAntiAffinity{
-		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
-			{
-				LabelSelector: &metav1.LabelSelector{
-					MatchExpressions: []metav1.LabelSelectorRequirement{
-						{
-							Key:      "foo",
-							Operator: metav1.LabelSelectorOpIn,
-							Values:   []string{"bar"},
-						},
-					},
-				},
-				TopologyKey: "region",
-			},
-		},
-	}
-	antiAffinityComplex := &v1.PodAntiAffinity{
-		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
-			{
-				LabelSelector: &metav1.LabelSelector{
-					MatchExpressions: []metav1.LabelSelectorRequirement{
-						{
-							Key:      "foo",
-							Operator: metav1.LabelSelectorOpIn,
-							Values:   []string{"bar", "buzz"},
-						},
-					},
-				},
-				TopologyKey: "region",
-			},
-			{
-				LabelSelector: &metav1.LabelSelector{
-					MatchExpressions: []metav1.LabelSelectorRequirement{
-						{
-							Key:      "service",
-							Operator: metav1.LabelSelectorOpNotIn,
-							Values:   []string{"bar", "security", "test"},
-						},
-					},
-				},
-				TopologyKey: "zone",
-			},
-		},
-	}
-	affinityComplex := &v1.PodAffinity{
-		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
-			{
-				LabelSelector: &metav1.LabelSelector{
-					MatchExpressions: []metav1.LabelSelectorRequirement{
-						{
-							Key:      "foo",
-							Operator: metav1.LabelSelectorOpIn,
-							Values:   []string{"bar", "buzz"},
-						},
-					},
-				},
-				TopologyKey: "region",
-			},
-			{
-				LabelSelector: &metav1.LabelSelector{
-					MatchExpressions: []metav1.LabelSelectorRequirement{
-						{
-							Key:      "service",
-							Operator: metav1.LabelSelectorOpNotIn,
-							Values:   []string{"bar", "security", "test"},
-						},
-					},
-				},
-				TopologyKey: "zone",
-			},
-		},
-	}
 
 	tests := []struct {
 		name         string
@@ -218,39 +137,6 @@ func TestPredicateMetadata_AddRemovePod(t *testing.T) {
 				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
 			},
 		},
-		{
-			name: "metadata anti-affinity terms are updated correctly after adding and removing a pod",
-			pendingPod: &v1.Pod{
-				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
-			},
-			existingPods: []*v1.Pod{
-				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
-					Spec: v1.PodSpec{NodeName: "nodeA"},
-				},
-				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
-					Spec: v1.PodSpec{
-						NodeName: "nodeC",
-						Affinity: &v1.Affinity{
-							PodAntiAffinity: antiAffinityFooBar,
-						},
-					},
-				},
-			},
-			addedPod: &v1.Pod{
-				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
-				Spec: v1.PodSpec{
-					NodeName: "nodeB",
-					Affinity: &v1.Affinity{
-						PodAntiAffinity: antiAffinityFooBar,
-					},
-				},
-			},
-			nodes: []*v1.Node{
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
-			},
-		},
 		{
 			name: "metadata service-affinity data are updated correctly after adding and removing a pod",
 			pendingPod: &v1.Pod{
@@ -275,75 +161,6 @@ func TestPredicateMetadata_AddRemovePod(t *testing.T) {
 				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
 			},
 		},
-		{
-			name: "metadata anti-affinity terms and service affinity data are updated correctly after adding and removing a pod",
-			pendingPod: &v1.Pod{
-				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
-			},
-			existingPods: []*v1.Pod{
-				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
-					Spec: v1.PodSpec{NodeName: "nodeA"},
-				},
-				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
-					Spec: v1.PodSpec{
-						NodeName: "nodeC",
-						Affinity: &v1.Affinity{
-							PodAntiAffinity: antiAffinityFooBar,
-						},
-					},
-				},
-			},
-			addedPod: &v1.Pod{
-				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
-				Spec: v1.PodSpec{
-					NodeName: "nodeA",
-					Affinity: &v1.Affinity{
-						PodAntiAffinity: antiAffinityComplex,
-					},
-				},
-			},
-			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: selector1}}},
-			nodes: []*v1.Node{
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
-			},
-		},
-		{
-			name: "metadata matching pod affinity and anti-affinity are updated correctly after adding and removing a pod",
-			pendingPod: &v1.Pod{
-				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
-			},
-			existingPods: []*v1.Pod{
-				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
-					Spec: v1.PodSpec{NodeName: "nodeA"},
-				},
-				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
-					Spec: v1.PodSpec{
-						NodeName: "nodeC",
-						Affinity: &v1.Affinity{
-							PodAntiAffinity: antiAffinityFooBar,
-							PodAffinity:     affinityComplex,
-						},
-					},
-				},
-			},
-			addedPod: &v1.Pod{
-				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
-				Spec: v1.PodSpec{
-					NodeName: "nodeA",
-					Affinity: &v1.Affinity{
-						PodAntiAffinity: antiAffinityComplex,
-					},
-				},
-			},
-			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: selector1}}},
-			nodes: []*v1.Node{
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
-				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
-			},
-		},
 	}
 
 	for _, test := range tests {
@@ -385,6 +202,31 @@ func TestPredicateMetadata_AddRemovePod(t *testing.T) {
 	}
 }
 
+func TestPodAffinityMetadata_Clone(t *testing.T) {
+	source := &PodAffinityMetadata{
+		topologyToMatchedExistingAntiAffinityTerms: topologyToMatchedTermCount{
+			{key: "name", value: "machine1"}: 1,
+			{key: "name", value: "machine2"}: 1,
+		},
+		topologyToMatchedAffinityTerms: topologyToMatchedTermCount{
+			{key: "name", value: "nodeA"}: 1,
+			{key: "name", value: "nodeC"}: 2,
+		},
+		topologyToMatchedAntiAffinityTerms: topologyToMatchedTermCount{
+			{key: "name", value: "nodeN"}: 3,
+			{key: "name", value: "nodeM"}: 1,
+		},
+	}
+
+	clone := source.Clone()
+	if clone == source {
+		t.Errorf("Clone returned the exact same object!")
+	}
+	if !reflect.DeepEqual(clone, source) {
+		t.Errorf("Copy is not equal to source!")
+	}
+}
+
 // TestPredicateMetadata_ShallowCopy tests the ShallowCopy function. It is based
 // on the idea that shallow-copy should produce an object that is deep-equal to the original
 // object.
@@ -415,20 +257,6 @@ func TestPredicateMetadata_ShallowCopy(t *testing.T) {
 				},
 			},
 		},
-		podAffinityMetadata: &podAffinityMetadata{
-			topologyToMatchedExistingAntiAffinityTerms: topologyToMatchedTermCount{
-				{key: "name", value: "machine1"}: 1,
-				{key: "name", value: "machine2"}: 1,
-			},
-			topologyToMatchedAffinityTerms: topologyToMatchedTermCount{
-				{key: "name", value: "nodeA"}: 1,
-				{key: "name", value: "nodeC"}: 2,
-			},
-			topologyToMatchedAntiAffinityTerms: topologyToMatchedTermCount{
-				{key: "name", value: "nodeN"}: 3,
-				{key: "name", value: "nodeM"}: 1,
-			},
-		},
 		evenPodsSpreadMetadata: &evenPodsSpreadMetadata{
 			tpKeyToCriticalPaths: map[string]*criticalPaths{
 				"name": {{"nodeA", 1}, {"nodeC", 2}},

pkg/scheduler/algorithm/predicates/predicates.go

@@ -1194,23 +1194,30 @@ type PodAffinityChecker struct {
 	podLister      schedulerlisters.PodLister
 }
 
+// NewPodAffinityChecker returns a PodAffinityChecker.
+func NewPodAffinityChecker(sharedLister schedulerlisters.SharedLister) *PodAffinityChecker {
+	return &PodAffinityChecker{
+		nodeInfoLister: sharedLister.NodeInfos(),
+		podLister:      sharedLister.Pods(),
+	}
+}
+
 // NewPodAffinityPredicate creates a PodAffinityChecker.
 func NewPodAffinityPredicate(nodeInfoLister schedulerlisters.NodeInfoLister, podLister schedulerlisters.PodLister) FitPredicate {
-	checker := &PodAffinityChecker{
+	return func(pod *v1.Pod, meta Metadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []PredicateFailureReason, error) {
-		nodeInfoLister: nodeInfoLister,
+		return false, nil, fmt.Errorf("This function should never be called")
-		podLister:      podLister,
 	}
-	return checker.InterPodAffinityMatches
 }
 
 // InterPodAffinityMatches checks if a pod can be scheduled on the specified node with pod affinity/anti-affinity configuration.
 // First return value indicates whether a pod can be scheduled on the specified node while the second return value indicates the
 // predicate failure reasons if the pod cannot be scheduled on the specified node.
-func (c *PodAffinityChecker) InterPodAffinityMatches(pod *v1.Pod, meta Metadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []PredicateFailureReason, error) {
+func (c *PodAffinityChecker) InterPodAffinityMatches(pod *v1.Pod, meta *PodAffinityMetadata, nodeInfo *schedulernodeinfo.NodeInfo) (bool, []PredicateFailureReason, error) {
 	node := nodeInfo.Node()
 	if node == nil {
 		return false, nil, fmt.Errorf("node not found")
 	}
+
 	if failedPredicates, error := c.satisfiesExistingPodsAntiAffinity(pod, meta, nodeInfo); failedPredicates != nil {
 		failedPredicates := append([]PredicateFailureReason{ErrPodAffinityNotMatch}, failedPredicates)
 		return false, failedPredicates, error
@@ -1341,14 +1348,14 @@ func (c *PodAffinityChecker) getMatchingAntiAffinityTopologyPairsOfPods(pod *v1.
 
 // Checks if scheduling the pod onto this node would break any anti-affinity
 // terms indicated by the existing pods.
-func (c *PodAffinityChecker) satisfiesExistingPodsAntiAffinity(pod *v1.Pod, meta Metadata, nodeInfo *schedulernodeinfo.NodeInfo) (PredicateFailureReason, error) {
+func (c *PodAffinityChecker) satisfiesExistingPodsAntiAffinity(pod *v1.Pod, meta *PodAffinityMetadata, nodeInfo *schedulernodeinfo.NodeInfo) (PredicateFailureReason, error) {
 	node := nodeInfo.Node()
 	if node == nil {
 		return ErrExistingPodsAntiAffinityRulesNotMatch, fmt.Errorf("node not found")
 	}
 	var topologyMap topologyToMatchedTermCount
-	if predicateMeta, ok := meta.(*predicateMetadata); ok {
+	if meta != nil {
-		topologyMap = predicateMeta.podAffinityMetadata.topologyToMatchedExistingAntiAffinityTerms
+		topologyMap = meta.topologyToMatchedExistingAntiAffinityTerms
 	} else {
 		// Filter out pods whose nodeName is equal to nodeInfo.node.Name, but are not
 		// present in nodeInfo. Pods on other nodes pass the filter.
@@ -1416,15 +1423,15 @@ func (c *PodAffinityChecker) nodeMatchesAnyTopologyTerm(pod *v1.Pod, topologyPai
 
 // satisfiesPodsAffinityAntiAffinity checks if scheduling the pod onto this node would break any term of this pod.
 func (c *PodAffinityChecker) satisfiesPodsAffinityAntiAffinity(pod *v1.Pod,
-	meta Metadata, nodeInfo *schedulernodeinfo.NodeInfo,
+	predicateMeta *PodAffinityMetadata, nodeInfo *schedulernodeinfo.NodeInfo,
 	affinity *v1.Affinity) (PredicateFailureReason, error) {
 	node := nodeInfo.Node()
 	if node == nil {
 		return ErrPodAffinityRulesNotMatch, fmt.Errorf("node not found")
 	}
-	if predicateMeta, ok := meta.(*predicateMetadata); ok {
+	if predicateMeta != nil {
 		// Check all affinity terms.
-		topologyToMatchedAffinityTerms := predicateMeta.podAffinityMetadata.topologyToMatchedAffinityTerms
+		topologyToMatchedAffinityTerms := predicateMeta.topologyToMatchedAffinityTerms
 		if affinityTerms := GetPodAffinityTerms(affinity.PodAffinity); len(affinityTerms) > 0 {
 			matchExists := c.nodeMatchesAllTopologyTerms(pod, topologyToMatchedAffinityTerms, nodeInfo, affinityTerms)
 			if !matchExists {
@@ -1441,7 +1448,7 @@ func (c *PodAffinityChecker) satisfiesPodsAffinityAntiAffinity(pod *v1.Pod,
 		}
 
 		// Check all anti-affinity terms.
-		topologyToMatchedAntiAffinityTerms := predicateMeta.podAffinityMetadata.topologyToMatchedAntiAffinityTerms
+		topologyToMatchedAntiAffinityTerms := predicateMeta.topologyToMatchedAntiAffinityTerms
 		if antiAffinityTerms := GetPodAntiAffinityTerms(affinity.PodAntiAffinity); len(antiAffinityTerms) > 0 {
 			matchExists := c.nodeMatchesAnyTopologyTerm(pod, topologyToMatchedAntiAffinityTerms, nodeInfo, antiAffinityTerms)
 			if matchExists {

pkg/scheduler/apis/config/testing/compatibility_test.go

@@ -262,6 +262,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -327,6 +330,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -403,6 +409,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -490,6 +499,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -578,6 +590,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -670,6 +685,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -774,6 +792,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -880,6 +901,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -986,6 +1010,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},
@@ -1097,6 +1124,9 @@ func TestCompatibility_v1_Scheduler(t *testing.T) {
 			wantPredicates:   sets.NewString(),
 			wantPrioritizers: sets.NewString(),
 			wantPlugins: map[string][]config.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeName"},

pkg/scheduler/framework/plugins/default_registry.go

@@ -200,6 +200,7 @@ func NewDefaultConfigProducerRegistry() *ConfigProducerRegistry {
 	registry.RegisterPredicate(predicates.MatchInterPodAffinityPred,
 		func(_ ConfigProducerArgs) (plugins config.Plugins, pluginConfig []config.PluginConfig) {
 			plugins.Filter = appendToPluginSet(plugins.Filter, interpodaffinity.Name, nil)
+			plugins.PreFilter = appendToPluginSet(plugins.PreFilter, interpodaffinity.Name, nil)
 			return
 		})
 	registry.RegisterPredicate(predicates.EvenPodsSpreadPred,

pkg/scheduler/framework/plugins/interpodaffinity/BUILD

@@ -10,9 +10,11 @@ go_library(
         "//pkg/scheduler/algorithm/priorities:go_default_library",
         "//pkg/scheduler/framework/plugins/migration:go_default_library",
         "//pkg/scheduler/framework/v1alpha1:go_default_library",
+        "//pkg/scheduler/listers:go_default_library",
         "//pkg/scheduler/nodeinfo:go_default_library",
         "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/klog:go_default_library",
     ],
 )
 

pkg/scheduler/framework/plugins/interpodaffinity/interpod_affinity.go

@@ -20,39 +20,126 @@ import (
 	"context"
 	"fmt"
 
-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/klog"
+
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
 	"k8s.io/kubernetes/pkg/scheduler/algorithm/priorities"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/migration"
 	framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
+	schedulerlisters "k8s.io/kubernetes/pkg/scheduler/listers"
 	"k8s.io/kubernetes/pkg/scheduler/nodeinfo"
 )
 
 // InterPodAffinity is a plugin that checks inter pod affinity
 type InterPodAffinity struct {
-	handle    framework.FrameworkHandle
+	snapshotSharedLister schedulerlisters.SharedLister
-	predicate predicates.FitPredicate
+	podAffinityChecker   *predicates.PodAffinityChecker
 }
 
+var _ framework.PreFilterPlugin = &InterPodAffinity{}
 var _ framework.FilterPlugin = &InterPodAffinity{}
 var _ framework.ScorePlugin = &InterPodAffinity{}
 
-// Name is the name of the plugin used in the plugin registry and configurations.
+const (
-const Name = "InterPodAffinity"
+	// Name is the name of the plugin used in the plugin registry and configurations.
+	Name = "InterPodAffinity"
+
+	// preFilterStateKey is the key in CycleState to InterPodAffinity pre-computed data.
+	// Using the name of the plugin will likely help us avoid collisions with other plugins.
+	preFilterStateKey = "PreFilter" + Name
+)
+
+// preFilterState computed at PreFilter and used at Filter.
+type preFilterState struct {
+	meta *predicates.PodAffinityMetadata
+}
+
+// Clone the prefilter state.
+func (s *preFilterState) Clone() framework.StateData {
+	copy := &preFilterState{
+		meta: s.meta.Clone(),
+	}
+	return copy
+}
 
 // Name returns name of the plugin. It is used in logs, etc.
 func (pl *InterPodAffinity) Name() string {
 	return Name
 }
 
+// PreFilter invoked at the prefilter extension point.
+func (pl *InterPodAffinity) PreFilter(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod) *framework.Status {
+	var meta *predicates.PodAffinityMetadata
+	var allNodes []*nodeinfo.NodeInfo
+	var havePodsWithAffinityNodes []*nodeinfo.NodeInfo
+	var err error
+	if allNodes, err = pl.snapshotSharedLister.NodeInfos().List(); err != nil {
+		return framework.NewStatus(framework.Error, fmt.Sprintf("failed to list NodeInfos: %v", err))
+	}
+	if havePodsWithAffinityNodes, err = pl.snapshotSharedLister.NodeInfos().HavePodsWithAffinityList(); err != nil {
+		return framework.NewStatus(framework.Error, fmt.Sprintf("failed to list NodeInfos with pods with affinity: %v", err))
+	}
+	if meta, err = predicates.GetPodAffinityMetadata(pod, allNodes, havePodsWithAffinityNodes); err != nil {
+		return framework.NewStatus(framework.Error, fmt.Sprintf("Error calculating podAffinityMetadata: %v", err))
+	}
+
+	s := &preFilterState{
+		meta: meta,
+	}
+	cycleState.Write(preFilterStateKey, s)
+	return nil
+}
+
+// PreFilterExtensions returns prefilter extensions, pod add and remove.
+func (pl *InterPodAffinity) PreFilterExtensions() framework.PreFilterExtensions {
+	return pl
+}
+
+// AddPod from pre-computed data in cycleState.
+func (pl *InterPodAffinity) AddPod(ctx context.Context, cycleState *framework.CycleState, podToSchedule *v1.Pod, podToAdd *v1.Pod, nodeInfo *nodeinfo.NodeInfo) *framework.Status {
+	meta, err := getPodAffinityMetadata(cycleState)
+	if err != nil {
+		return framework.NewStatus(framework.Error, err.Error())
+	}
+	meta.UpdateWithPod(podToAdd, podToSchedule, nodeInfo.Node(), 1)
+	return nil
+}
+
+// RemovePod from pre-computed data in cycleState.
+func (pl *InterPodAffinity) RemovePod(ctx context.Context, cycleState *framework.CycleState, podToSchedule *v1.Pod, podToRemove *v1.Pod, nodeInfo *nodeinfo.NodeInfo) *framework.Status {
+	meta, err := getPodAffinityMetadata(cycleState)
+	if err != nil {
+		return framework.NewStatus(framework.Error, err.Error())
+	}
+	meta.UpdateWithPod(podToRemove, podToSchedule, nodeInfo.Node(), -1)
+	return nil
+}
+
+func getPodAffinityMetadata(cycleState *framework.CycleState) (*predicates.PodAffinityMetadata, error) {
+	c, err := cycleState.Read(preFilterStateKey)
+	if err != nil {
+		// The metadata wasn't pre-computed in prefilter. We ignore the error for now since
+		// Filter is able to handle that by computing it again.
+		klog.Error(err)
+		return nil, nil
+	}
+
+	s, ok := c.(*preFilterState)
+	if !ok {
+		return nil, fmt.Errorf("%+v  convert to interpodaffinity.state error", c)
+	}
+	return s.meta, nil
+}
+
 // Filter invoked at the filter extension point.
 func (pl *InterPodAffinity) Filter(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodeInfo *nodeinfo.NodeInfo) *framework.Status {
-	meta, ok := migration.CovertStateRefToPredMeta(migration.PredicateMetadata(cycleState))
+	meta, err := getPodAffinityMetadata(cycleState)
-	if !ok {
+	if err != nil {
-		return migration.ErrorToFrameworkStatus(fmt.Errorf("%+v convert to predicates.Metadata error", cycleState))
+		return framework.NewStatus(framework.Error, err.Error())
 	}
-	_, reasons, err := pl.predicate(pod, meta, nodeInfo)
+	_, reasons, err := pl.podAffinityChecker.InterPodAffinityMatches(pod, meta, nodeInfo)
 	return migration.PredicateResultToFrameworkStatus(reasons, err)
 }
 
@@ -60,7 +147,7 @@ func (pl *InterPodAffinity) Filter(ctx context.Context, cycleState *framework.Cy
 // The "score" returned in this function is the matching number of pods on the `nodeName`,
 // it is normalized later.
 func (pl *InterPodAffinity) Score(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
-	nodeInfo, err := pl.handle.SnapshotSharedLister().NodeInfos().Get(nodeName)
+	nodeInfo, err := pl.snapshotSharedLister.NodeInfos().Get(nodeName)
 	if err != nil {
 		return 0, framework.NewStatus(framework.Error, fmt.Sprintf("getting node %q from Snapshot: %v", nodeName, err))
 	}
@@ -73,7 +160,7 @@ func (pl *InterPodAffinity) Score(ctx context.Context, state *framework.CycleSta
 // NormalizeScore invoked after scoring all nodes.
 func (pl *InterPodAffinity) NormalizeScore(ctx context.Context, state *framework.CycleState, pod *v1.Pod, scores framework.NodeScoreList) *framework.Status {
 	meta := migration.PriorityMetadata(state)
-	err := priorities.CalculateInterPodAffinityPriorityReduce(pod, meta, pl.handle.SnapshotSharedLister(), scores)
+	err := priorities.CalculateInterPodAffinityPriorityReduce(pod, meta, pl.snapshotSharedLister, scores)
 	return migration.ErrorToFrameworkStatus(err)
 }
 
@@ -84,8 +171,11 @@ func (pl *InterPodAffinity) ScoreExtensions() framework.ScoreExtensions {
 
 // New initializes a new plugin and returns it.
 func New(_ *runtime.Unknown, h framework.FrameworkHandle) (framework.Plugin, error) {
+	if h.SnapshotSharedLister() == nil {
+		return nil, fmt.Errorf("SnapshotSharedlister is nil")
+	}
 	return &InterPodAffinity{
-		handle:    h,
+		snapshotSharedLister: h.SnapshotSharedLister(),
-		predicate: predicates.NewPodAffinityPredicate(h.SnapshotSharedLister().NodeInfos(), h.SnapshotSharedLister().Pods()),
+		podAffinityChecker:   predicates.NewPodAffinityChecker(h.SnapshotSharedLister()),
 	}, nil
 }

pkg/scheduler/framework/plugins/interpodaffinity/interpod_affinity_test.go

@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"testing"
 
-	v1 "k8s.io/api/core/v1"
+	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/informers"
 	clientsetfake "k8s.io/client-go/kubernetes/fake"
@@ -782,13 +782,14 @@ func TestSingleNode(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			snapshot := nodeinfosnapshot.NewSnapshot(nodeinfosnapshot.CreateNodeInfoMap(test.pods, []*v1.Node{test.node}))
-			factory := &predicates.MetadataProducerFactory{}
-			meta := factory.GetPredicateMetadata(test.pod, snapshot)
-			state := framework.NewCycleState()
-			state.Write(migration.PredicatesStateKey, &migration.PredicatesStateData{Reference: meta})
-
 			p := &InterPodAffinity{
-				predicate: predicates.NewPodAffinityPredicate(snapshot.NodeInfos(), snapshot.Pods()),
+				snapshotSharedLister: snapshot,
+				podAffinityChecker:   predicates.NewPodAffinityChecker(snapshot),
+			}
+			state := framework.NewCycleState()
+			preFilterStatus := p.PreFilter(context.Background(), state, test.pod)
+			if !preFilterStatus.IsSuccess() {
+				t.Errorf("prefilter failed with status: %v", preFilterStatus)
 			}
 			gotStatus := p.Filter(context.Background(), state, test.pod, snapshot.NodeInfoMap[test.node.Name])
 			if !reflect.DeepEqual(gotStatus, test.wantStatus) {
@@ -1619,13 +1620,14 @@ func TestMultipleNodes(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			snapshot := nodeinfosnapshot.NewSnapshot(nodeinfosnapshot.CreateNodeInfoMap(test.pods, test.nodes))
 			for indexNode, node := range test.nodes {
-				factory := &predicates.MetadataProducerFactory{}
-				meta := factory.GetPredicateMetadata(test.pod, snapshot)
-				state := framework.NewCycleState()
-				state.Write(migration.PredicatesStateKey, &migration.PredicatesStateData{Reference: meta})
-
 				p := &InterPodAffinity{
-					predicate: predicates.NewPodAffinityPredicate(snapshot.NodeInfos(), snapshot.Pods()),
+					snapshotSharedLister: snapshot,
+					podAffinityChecker:   predicates.NewPodAffinityChecker(snapshot),
+				}
+				state := framework.NewCycleState()
+				preFilterStatus := p.PreFilter(context.Background(), state, test.pod)
+				if !preFilterStatus.IsSuccess() {
+					t.Errorf("prefilter failed with status: %v", preFilterStatus)
 				}
 				gotStatus := p.Filter(context.Background(), state, test.pod, snapshot.NodeInfoMap[node.Name])
 				if !reflect.DeepEqual(gotStatus, test.wantStatuses[indexNode]) {
@@ -2279,3 +2281,277 @@ func TestHardPodAffinitySymmetricWeight(t *testing.T) {
 		})
 	}
 }
+
+func TestStateAddRemovePod(t *testing.T) {
+	var label1 = map[string]string{
+		"region": "r1",
+		"zone":   "z11",
+	}
+	var label2 = map[string]string{
+		"region": "r1",
+		"zone":   "z12",
+	}
+	var label3 = map[string]string{
+		"region": "r2",
+		"zone":   "z21",
+	}
+	selector1 := map[string]string{"foo": "bar"}
+	antiAffinityFooBar := &v1.PodAntiAffinity{
+		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "foo",
+							Operator: metav1.LabelSelectorOpIn,
+							Values:   []string{"bar"},
+						},
+					},
+				},
+				TopologyKey: "region",
+			},
+		},
+	}
+	antiAffinityComplex := &v1.PodAntiAffinity{
+		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "foo",
+							Operator: metav1.LabelSelectorOpIn,
+							Values:   []string{"bar", "buzz"},
+						},
+					},
+				},
+				TopologyKey: "region",
+			},
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "service",
+							Operator: metav1.LabelSelectorOpNotIn,
+							Values:   []string{"bar", "security", "test"},
+						},
+					},
+				},
+				TopologyKey: "zone",
+			},
+		},
+	}
+	affinityComplex := &v1.PodAffinity{
+		RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "foo",
+							Operator: metav1.LabelSelectorOpIn,
+							Values:   []string{"bar", "buzz"},
+						},
+					},
+				},
+				TopologyKey: "region",
+			},
+			{
+				LabelSelector: &metav1.LabelSelector{
+					MatchExpressions: []metav1.LabelSelectorRequirement{
+						{
+							Key:      "service",
+							Operator: metav1.LabelSelectorOpNotIn,
+							Values:   []string{"bar", "security", "test"},
+						},
+					},
+				},
+				TopologyKey: "zone",
+			},
+		},
+	}
+
+	tests := []struct {
+		name         string
+		pendingPod   *v1.Pod
+		addedPod     *v1.Pod
+		existingPods []*v1.Pod
+		nodes        []*v1.Node
+		services     []*v1.Service
+	}{
+		{
+			name: "no affinity exist",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{NodeName: "nodeC"},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec:       v1.PodSpec{NodeName: "nodeB"},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+		{
+			name: "metadata anti-affinity terms are updated correctly after adding and removing a pod",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{
+						NodeName: "nodeC",
+						Affinity: &v1.Affinity{
+							PodAntiAffinity: antiAffinityFooBar,
+						},
+					},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec: v1.PodSpec{
+					NodeName: "nodeB",
+					Affinity: &v1.Affinity{
+						PodAntiAffinity: antiAffinityFooBar,
+					},
+				},
+			},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+		{
+			name: "metadata anti-affinity terms are updated correctly after adding and removing a pod",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{
+						NodeName: "nodeC",
+						Affinity: &v1.Affinity{
+							PodAntiAffinity: antiAffinityFooBar,
+						},
+					},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec: v1.PodSpec{
+					NodeName: "nodeA",
+					Affinity: &v1.Affinity{
+						PodAntiAffinity: antiAffinityComplex,
+					},
+				},
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: selector1}}},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+		{
+			name: "metadata matching pod affinity and anti-affinity are updated correctly after adding and removing a pod",
+			pendingPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "pending", Labels: selector1},
+			},
+			existingPods: []*v1.Pod{
+				{ObjectMeta: metav1.ObjectMeta{Name: "p1", Labels: selector1},
+					Spec: v1.PodSpec{NodeName: "nodeA"},
+				},
+				{ObjectMeta: metav1.ObjectMeta{Name: "p2"},
+					Spec: v1.PodSpec{
+						NodeName: "nodeC",
+						Affinity: &v1.Affinity{
+							PodAntiAffinity: antiAffinityFooBar,
+							PodAffinity:     affinityComplex,
+						},
+					},
+				},
+			},
+			addedPod: &v1.Pod{
+				ObjectMeta: metav1.ObjectMeta{Name: "addedPod", Labels: selector1},
+				Spec: v1.PodSpec{
+					NodeName: "nodeA",
+					Affinity: &v1.Affinity{
+						PodAntiAffinity: antiAffinityComplex,
+					},
+				},
+			},
+			services: []*v1.Service{{Spec: v1.ServiceSpec{Selector: selector1}}},
+			nodes: []*v1.Node{
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeA", Labels: label1}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeB", Labels: label2}},
+				{ObjectMeta: metav1.ObjectMeta{Name: "nodeC", Labels: label3}},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			// getMeta creates predicate meta data given the list of pods.
+			getState := func(pods []*v1.Pod) (*InterPodAffinity, *framework.CycleState, *predicates.PodAffinityMetadata, *nodeinfosnapshot.Snapshot) {
+				snapshot := nodeinfosnapshot.NewSnapshot(nodeinfosnapshot.CreateNodeInfoMap(pods, test.nodes))
+
+				p := &InterPodAffinity{
+					snapshotSharedLister: snapshot,
+					podAffinityChecker:   predicates.NewPodAffinityChecker(snapshot),
+				}
+				cycleState := framework.NewCycleState()
+				preFilterStatus := p.PreFilter(context.Background(), cycleState, test.pendingPod)
+				if !preFilterStatus.IsSuccess() {
+					t.Errorf("prefilter failed with status: %v", preFilterStatus)
+				}
+
+				meta, err := getPodAffinityMetadata(cycleState)
+				if err != nil {
+					t.Errorf("failed to get metadata from cycleState: %v", err)
+				}
+
+				return p, cycleState, meta, snapshot
+			}
+
+			// allPodsState is the state produced when all pods, including test.addedPod are given to prefilter.
+			_, _, allPodsMeta, _ := getState(append(test.existingPods, test.addedPod))
+
+			// state is produced for test.existingPods (without test.addedPod).
+			ipa, state, meta, snapshot := getState(test.existingPods)
+			// clone the state so that we can compare it later when performing Remove.
+			originalMeta := meta.Clone()
+
+			// Add test.addedPod to state1 and verify it is equal to allPodsState.
+			if err := ipa.AddPod(context.Background(), state, test.pendingPod, test.addedPod, snapshot.NodeInfoMap[test.addedPod.Spec.NodeName]); err != nil {
+				t.Errorf("error adding pod to meta: %v", err)
+			}
+
+			if !reflect.DeepEqual(allPodsMeta, meta) {
+				t.Errorf("State is not equal, got: %v, want: %v", meta, allPodsMeta)
+			}
+
+			// Remove the added pod pod and make sure it is equal to the original state.
+			if err := ipa.RemovePod(context.Background(), state, test.pendingPod, test.addedPod, snapshot.NodeInfoMap[test.addedPod.Spec.NodeName]); err != nil {
+				t.Errorf("error removing pod from meta: %v", err)
+			}
+			if !reflect.DeepEqual(originalMeta, meta) {
+				t.Errorf("State is not equal, got: %v, want: %v", meta, originalMeta)
+			}
+		})
+	}
+}

test/integration/scheduler/scheduler_test.go

@@ -131,6 +131,9 @@ func TestSchedulerCreationFromConfigMap(t *testing.T) {
 			}`,
 			expectedPrioritizers: sets.NewString(),
 			expectedPlugins: map[string][]kubeschedulerconfig.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeResourcesFit"},
@@ -208,6 +211,9 @@ kind: Policy
 `,
 			expectedPrioritizers: sets.NewString(),
 			expectedPlugins: map[string][]kubeschedulerconfig.Plugin{
+				"PreFilterPlugin": {
+					{Name: "InterPodAffinity"},
+				},
 				"FilterPlugin": {
 					{Name: "NodeUnschedulable"},
 					{Name: "NodeResourcesFit"},