skip calculate available replicas when no need

Signed-off-by: zhzhuang-zju <[email protected]>

Author: zhzhuang-zju

pkg/scheduler/core/spreadconstraint/group_clusters.go

@@ -95,6 +95,9 @@ func GroupClustersWithScore(
 	calAvailableReplicasFunc func(clusters []*clusterv1alpha1.Cluster, spec *workv1alpha2.ResourceBindingSpec) []workv1alpha2.TargetCluster,
 ) *GroupClustersInfo {
 	if isTopologyIgnored(placement) {
+		if shouldIgnoreCalculateAvailableResource(placement) {
+			return groupClustersIgnoringTopology(clustersScore, spec, nil)
+		}
 		return groupClustersIgnoringTopology(clustersScore, spec, calAvailableReplicasFunc)
 	}
 
@@ -343,11 +346,13 @@ func (info *GroupClustersInfo) generateClustersInfo(clustersScore framework.Clus
 		clusters = append(clusters, clusterScore.Cluster)
 	}
 
-	clustersReplicas := info.calAvailableReplicasFunc(clusters, rbSpec)
-	for i, clustersReplica := range clustersReplicas {
-		info.Clusters[i].AvailableReplicas = int64(clustersReplica.Replicas)
-		info.Clusters[i].AvailableReplicas += int64(rbSpec.AssignedReplicasForCluster(clustersReplica.Name))
-		info.Clusters[i].AllocatableReplicas = clustersReplica.Replicas
+	if info.calAvailableReplicasFunc != nil {
+		clustersReplicas := info.calAvailableReplicasFunc(clusters, rbSpec)
+		for i, clustersReplica := range clustersReplicas {
+			info.Clusters[i].AvailableReplicas = int64(clustersReplica.Replicas)
+			info.Clusters[i].AvailableReplicas += int64(rbSpec.AssignedReplicasForCluster(clustersReplica.Name))
+			info.Clusters[i].AllocatableReplicas = clustersReplica.Replicas
+		}
 	}
 
 	sortClusters(info.Clusters, func(i *ClusterDetailInfo, j *ClusterDetailInfo) *bool {

pkg/scheduler/core/spreadconstraint/group_clusters_test.go

@@ -201,6 +201,7 @@ func Test_GroupClustersWithScore(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			tt.args.spec.Placement = tt.args.placement
 			groupInfo := GroupClustersWithScore(tt.args.clustersScore, tt.args.placement, tt.args.spec, calAvailableReplicasFunc)
 			for i, cluster := range groupInfo.Clusters {
 				if cluster.Name != tt.want.clusters[i] {

pkg/scheduler/core/spreadconstraint/select_clusters.go

@@ -78,3 +78,15 @@ func shouldIgnoreAvailableResource(placement *policyv1alpha1.Placement) bool {
 
 	return false
 }
+
+// when replica assignment strategy is "Duplicated" or "static weighted", no need to calculate the available resource
+func shouldIgnoreCalculateAvailableResource(placement *policyv1alpha1.Placement) bool {
+	strategy := placement.ReplicaSchedulingType()
+	if strategy == policyv1alpha1.ReplicaSchedulingTypeDuplicated {
+		return true
+	}
+	if strategy == policyv1alpha1.ReplicaSchedulingTypeDivided && placement.ReplicaScheduling.ReplicaDivisionPreference == policyv1alpha1.ReplicaDivisionPreferenceWeighted && (placement.ReplicaScheduling.WeightPreference == nil || len(placement.ReplicaScheduling.WeightPreference.DynamicWeight) == 0) {
+		return true
+	}
+	return false
+}

pkg/scheduler/core/spreadconstraint/select_clusters_test.go

@@ -249,3 +249,75 @@ func TestSelectBestClusters(t *testing.T) {
 		})
 	}
 }
+
+func TestIgnoreCalculateAvailableResource(t *testing.T) {
+	tests := []struct {
+		name      string
+		placement *policyv1alpha1.Placement
+		ignore    bool
+	}{
+		{
+			name:      "when ReplicaScheduling is nil",
+			placement: &policyv1alpha1.Placement{ReplicaScheduling: nil},
+			ignore:    true,
+		},
+		{
+			name: "when strategy is duplicated",
+			placement: &policyv1alpha1.Placement{
+				ReplicaScheduling: &policyv1alpha1.ReplicaSchedulingStrategy{ReplicaSchedulingType: policyv1alpha1.ReplicaSchedulingTypeDuplicated},
+			},
+			ignore: true,
+		},
+		{
+			name: "when strategy is divided, and ReplicaDivisionPreference is Aggregated",
+			placement: &policyv1alpha1.Placement{
+				ReplicaScheduling: &policyv1alpha1.ReplicaSchedulingStrategy{
+					ReplicaSchedulingType:     policyv1alpha1.ReplicaSchedulingTypeDivided,
+					ReplicaDivisionPreference: policyv1alpha1.ReplicaDivisionPreferenceAggregated,
+				},
+			},
+			ignore: false,
+		},
+		{
+			name: "when strategy is divided, and ReplicaDivisionPreference is Weighted, and WeightPreference is nil",
+			placement: &policyv1alpha1.Placement{
+				ReplicaScheduling: &policyv1alpha1.ReplicaSchedulingStrategy{
+					ReplicaSchedulingType:     policyv1alpha1.ReplicaSchedulingTypeDivided,
+					ReplicaDivisionPreference: policyv1alpha1.ReplicaDivisionPreferenceWeighted,
+					WeightPreference:          nil,
+				},
+			},
+			ignore: true,
+		},
+		{
+			name: "when strategy is divided, and ReplicaDivisionPreference is Weighted, and WeightPreference is DynamicWeight",
+			placement: &policyv1alpha1.Placement{
+				ReplicaScheduling: &policyv1alpha1.ReplicaSchedulingStrategy{
+					ReplicaSchedulingType:     policyv1alpha1.ReplicaSchedulingTypeDivided,
+					ReplicaDivisionPreference: policyv1alpha1.ReplicaDivisionPreferenceWeighted,
+					WeightPreference:          &policyv1alpha1.ClusterPreferences{DynamicWeight: policyv1alpha1.DynamicWeightByAvailableReplicas},
+				},
+			},
+			ignore: false,
+		},
+		{
+			name: "when strategy is divided, and ReplicaDivisionPreference is Weighted, and WeightPreference is StaticWeightList",
+			placement: &policyv1alpha1.Placement{
+				ReplicaScheduling: &policyv1alpha1.ReplicaSchedulingStrategy{
+					ReplicaSchedulingType:     policyv1alpha1.ReplicaSchedulingTypeDivided,
+					ReplicaDivisionPreference: policyv1alpha1.ReplicaDivisionPreferenceWeighted,
+					WeightPreference:          &policyv1alpha1.ClusterPreferences{StaticWeightList: make([]policyv1alpha1.StaticClusterWeight, 0)},
+				},
+			},
+			ignore: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := shouldIgnoreCalculateAvailableResource(tt.placement)
+			if !reflect.DeepEqual(got, tt.ignore) {
+				t.Errorf("shouldIgnoreCalculateAvailableResource() = %v, want %v", got, tt.ignore)
+			}
+		})
+	}
+}