Merge pull request volcano-sh#1851 from aidaizyy/aidaizyy-dev

volcano-sh-bot · web-flow · commit c2383539e714 · 2021-11-27T11:33:56.000+08:00
fix pod cannot be allocated with sufficient resource
diff --git a/pkg/scheduler/api/resource_info.go b/pkg/scheduler/api/resource_info.go
@@ -480,27 +480,40 @@ func (r *Resource) SetScalar(name v1.ResourceName, quantity float64) {
 // e.g r resource is <cpu 2000.00, memory 4047845376.00, hugepages-2Mi 0.00, hugepages-1Gi 0.00>
 // rr resource is <cpu 3000.00, memory 1000.00>
 // return r resource is <cpu 2000.00, memory 1000.00, hugepages-2Mi 0.00, hugepages-1Gi 0.00>
-func (r *Resource) MinDimensionResource(rr *Resource) *Resource {
+// @param defaultValue "default value for resource dimension not defined in ScalarResources. Its value can only be one of 'Zero' and 'Infinity'"
+func (r *Resource) MinDimensionResource(rr *Resource, defaultValue DimensionDefaultValue) *Resource {
 	if rr.MilliCPU < r.MilliCPU {
 		r.MilliCPU = rr.MilliCPU
 	}
 	if rr.Memory < r.Memory {
 		r.Memory = rr.Memory
 	}
 
+	if r.ScalarResources == nil {
+		return r
+	}
+
 	if rr.ScalarResources == nil {
-		if r.ScalarResources != nil {
-			for name := range r.ScalarResources {
-				r.ScalarResources[name] = 0
-			}
+		if defaultValue == Infinity {
+			return r
 		}
-	} else {
-		if r.ScalarResources != nil {
-			for name, quant := range rr.ScalarResources {
-				if quant < r.ScalarResources[name] {
-					r.ScalarResources[name] = quant
-				}
+
+		for name := range r.ScalarResources {
+			r.ScalarResources[name] = 0
+		}
+		return r
+	}
+
+	for name, quant := range r.ScalarResources {
+		rQuant, ok := rr.ScalarResources[name]
+		if ok {
+			r.ScalarResources[name] = math.Min(quant, rQuant)
+		} else {
+			if defaultValue == Infinity {
+				continue
 			}
+
+			r.ScalarResources[name] = 0
 		}
 	}
 	return r
diff --git a/pkg/scheduler/api/resource_info_test.go b/pkg/scheduler/api/resource_info_test.go
@@ -17,6 +17,7 @@ limitations under the License.
 package api
 
 import (
+	"math"
 	"reflect"
 	"testing"
 
@@ -1091,7 +1092,7 @@ func TestEqual(t *testing.T) {
 	}
 }
 
-func TestMinDimensionResource(t *testing.T) {
+func TestMinDimensionResourceZero(t *testing.T) {
 	tests := []struct {
 		resource1 *Resource
 		resource2 *Resource
@@ -1131,10 +1132,92 @@ func TestMinDimensionResource(t *testing.T) {
 				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 2000},
 			},
 		},
+		{
+			resource1: &Resource{
+				MilliCPU:        4000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
+			},
+			resource2: &Resource{
+				MilliCPU:        3000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0},
+			},
+			expected: &Resource{
+				MilliCPU:        3000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 0},
+			},
+		},
+		{
+			resource1: &Resource{
+				MilliCPU:        4000,
+				Memory:          4000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
+			},
+			resource2: &Resource{
+				MilliCPU: math.MaxFloat64,
+				Memory:   2000,
+			},
+			expected: &Resource{
+				MilliCPU:        4000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 0},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test.resource1.MinDimensionResource(test.resource2, Zero)
+		if !reflect.DeepEqual(test.expected, test.resource1) {
+			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
+		}
+	}
+}
+
+func TestMinDimensionResourceInfinity(t *testing.T) {
+	tests := []struct {
+		resource1 *Resource
+		resource2 *Resource
+		expected  *Resource
+	}{
+		{
+			resource1: &Resource{
+				MilliCPU:        4000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1, "hugepages-test": 2},
+			},
+			resource2: &Resource{
+				MilliCPU:        3000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0},
+			},
+			expected: &Resource{
+				MilliCPU:        3000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 0, "hugepages-test": 2},
+			},
+		},
+		{
+			resource1: &Resource{
+				MilliCPU:        4000,
+				Memory:          4000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
+			},
+			resource2: &Resource{
+				MilliCPU: math.MaxFloat64,
+				Memory:   2000,
+			},
+			expected: &Resource{
+				MilliCPU:        4000,
+				Memory:          2000,
+				ScalarResources: map[v1.ResourceName]float64{"scalar.test/scalar1": 1000, "hugepages-test": 2000},
+			},
+		},
 	}
 
 	for _, test := range tests {
-		test.resource1.MinDimensionResource(test.resource2)
+		test.resource1.MinDimensionResource(test.resource2, Infinity)
 		if !reflect.DeepEqual(test.expected, test.resource1) {
 			t.Errorf("expected: %#v, got: %#v", test.expected, test.resource1)
 		}
diff --git a/pkg/scheduler/plugins/proportion/proportion.go b/pkg/scheduler/plugins/proportion/proportion.go
@@ -17,6 +17,7 @@ limitations under the License.
 package proportion
 
 import (
+	"math"
 	"reflect"
 
 	v1 "k8s.io/api/core/v1"
@@ -90,6 +91,12 @@ func (pp *proportionPlugin) OnSessionOpen(ssn *framework.Session) {
 			}
 			if len(queue.Queue.Spec.Capability) != 0 {
 				attr.capability = api.NewResource(queue.Queue.Spec.Capability)
+				if attr.capability.MilliCPU <= 0 {
+					attr.capability.MilliCPU = math.MaxFloat64
+				}
+				if attr.capability.Memory <= 0 {
+					attr.capability.Memory = math.MaxFloat64
+				}
 			}
 
 			pp.queueOpts[job.Queue] = attr
@@ -160,18 +167,18 @@ func (pp *proportionPlugin) OnSessionOpen(ssn *framework.Session) {
 			oldDeserved := attr.deserved.Clone()
 			attr.deserved.Add(remaining.Clone().Multi(float64(attr.weight) / float64(totalWeight)))
 
-			if attr.capability != nil && !attr.deserved.LessEqual(attr.capability, api.Infinity) {
-				attr.deserved = helpers.Min(attr.deserved, attr.capability)
-				attr.deserved = helpers.Min(attr.deserved, attr.request)
-				meet[attr.queueID] = struct{}{}
-				klog.V(4).Infof("queue <%s> is meet cause of the capability", attr.name)
-			} else if attr.request.LessEqual(attr.deserved, api.Zero) {
-				attr.deserved = helpers.Min(attr.deserved, attr.request)
+			if attr.capability != nil {
+				attr.deserved.MinDimensionResource(attr.capability, api.Infinity)
+			}
+			attr.deserved.MinDimensionResource(attr.request, api.Zero)
+			klog.V(4).Infof("Format queue <%s> deserved resource to <%v>", attr.name, attr.deserved)
+
+			if attr.request.LessEqual(attr.deserved, api.Zero) {
 				meet[attr.queueID] = struct{}{}
 				klog.V(4).Infof("queue <%s> is meet", attr.name)
-			} else {
-				attr.deserved.MinDimensionResource(attr.request)
-				klog.V(4).Infof("Format queue <%s> deserved resource to <%v>", attr.name, attr.deserved)
+			} else if reflect.DeepEqual(attr.deserved, oldDeserved) {
+				meet[attr.queueID] = struct{}{}
+				klog.V(4).Infof("queue <%s> is meet cause of the capability", attr.name)
 			}
 			pp.updateShare(attr)
 
