add LessEqualInAllDimension function and remove LessEqual/LessEqualSt…

…rict functions

Signed-off-by: Thor-wl <13164644535@163.com>

pkg/scheduler/actions/allocate/allocate.go

@@ -110,7 +110,7 @@ func (alloc *Action) Execute(ssn *framework.Session) {
 	}
 	predicateFn := func(task *api.TaskInfo, node *api.NodeInfo) error {
 		// Check for Resource Predicate
-		if !task.InitResreq.LessEqual(node.FutureIdle()) {
+		if !task.InitResreq.LessEqualInAllDimension(node.FutureIdle(), api.Zero) {
 			return api.NewFitError(task, node, api.NodeResourceFitFailed)
 		}
 
@@ -211,7 +211,7 @@ func (alloc *Action) Execute(ssn *framework.Session) {
 
 			var candidateNodes []*api.NodeInfo
 			for _, n := range predicateNodes {
-				if task.InitResreq.LessEqual(n.Idle) || task.InitResreq.LessEqual(n.FutureIdle()) {
+				if task.InitResreq.LessEqualInAllDimension(n.Idle, api.Zero) || task.InitResreq.LessEqualInAllDimension(n.FutureIdle(), api.Zero) {
 					candidateNodes = append(candidateNodes, n)
 				}
 			}
@@ -229,7 +229,7 @@ func (alloc *Action) Execute(ssn *framework.Session) {
 			}
 
 			// Allocate idle resource to the task.
-			if task.InitResreq.LessEqual(node.Idle) {
+			if task.InitResreq.LessEqualInAllDimension(node.Idle, api.Zero) {
 				klog.V(3).Infof("Binding Task <%v/%v> to node <%v>",
 					task.Namespace, task.Name, node.Name)
 				if err := stmt.Allocate(task, node); err != nil {
@@ -243,7 +243,7 @@ func (alloc *Action) Execute(ssn *framework.Session) {
 					task.Namespace, task.Name, node.Name)
 
 				// Allocate releasing resource to the task if any.
-				if task.InitResreq.LessEqual(node.FutureIdle()) {
+				if task.InitResreq.LessEqualInAllDimension(node.FutureIdle(), api.Zero) {
 					klog.V(3).Infof("Pipelining Task <%v/%v> to node <%v> for <%v> on <%v>",
 						task.Namespace, task.Name, node.Name, task.InitResreq, node.Releasing)
 					if err := stmt.Pipeline(task, node.Name); err != nil {

pkg/scheduler/actions/preempt/preempt.go

@@ -236,7 +236,7 @@ func preempt(
 
 		for !victimsQueue.Empty() {
 			// If reclaimed enough resources, break loop to avoid Sub panic.
-			if preemptor.InitResreq.LessEqual(node.FutureIdle()) {
+			if preemptor.InitResreq.LessEqualInAllDimension(node.FutureIdle(), api.Zero) {
 				break
 			}
 			preemptee := victimsQueue.Pop().(*api.TaskInfo)
@@ -254,7 +254,7 @@ func preempt(
 		klog.V(3).Infof("Preempted <%v> for Task <%s/%s> requested <%v>.",
 			preempted, preemptor.Namespace, preemptor.Name, preemptor.InitResreq)
 
-		if preemptor.InitResreq.LessEqual(node.FutureIdle()) {
+		if preemptor.InitResreq.LessEqualInAllDimension(node.FutureIdle(), api.Zero) {
 			if err := stmt.Pipeline(preemptor, node.Name); err != nil {
 				klog.Errorf("Failed to pipeline Task <%s/%s> on Node <%s>",
 					preemptor.Namespace, preemptor.Name, node.Name)

pkg/scheduler/actions/reclaim/reclaim.go

@@ -160,15 +160,15 @@ func (ra *Action) Execute(ssn *framework.Session) {
 				}
 				reclaimed.Add(reclaimee.Resreq)
 				// If reclaimed enough resources, break loop to avoid Sub panic.
-				if resreq.LessEqual(reclaimed) {
+				if resreq.LessEqualInAllDimension(reclaimed, api.Zero) {
 					break
 				}
 			}
 
 			klog.V(3).Infof("Reclaimed <%v> for task <%s/%s> requested <%v>.",
 				reclaimed, task.Namespace, task.Name, task.InitResreq)
 
-			if task.InitResreq.LessEqual(reclaimed) {
+			if task.InitResreq.LessEqualInAllDimension(reclaimed, api.Zero) {
 				if err := ssn.Pipeline(task, n.Name); err != nil {
 					klog.Errorf("Failed to pipeline Task <%s/%s> on Node <%s>",
 						task.Namespace, task.Name, n.Name)

pkg/scheduler/api/node_info.go

@@ -239,7 +239,7 @@ func (ni *NodeInfo) setNodeState(node *v1.Node) {
 	}
 
 	// set NodeState according to resources
-	if !ni.Used.LessEqual(ni.Allocatable) {
+	if !ni.Used.LessEqualInAllDimension(ni.Allocatable, Zero) {
 		ni.State = NodeState{
 			Phase:  NotReady,
 			Reason: "OutOfSync",
@@ -331,7 +331,7 @@ func (ni *NodeInfo) SetNode(node *v1.Node) {
 }
 
 func (ni *NodeInfo) allocateIdleResource(ti *TaskInfo) error {
-	if ti.Resreq.LessEqual(ni.Idle) {
+	if ti.Resreq.LessEqualInAllDimension(ni.Idle, Zero) {
 		ni.Idle.Sub(ti.Resreq)
 		return nil
 	}

pkg/scheduler/api/resource_info.go

@@ -189,7 +189,7 @@ func (r *Resource) Add(rr *Resource) *Resource {
 
 //Sub subtracts two Resource objects.
 func (r *Resource) Sub(rr *Resource) *Resource {
-	assert.Assertf(rr.LessEqual(r), "resource is not sufficient to do operation: <%v> sub <%v>", r, rr)
+	assert.Assertf(rr.LessEqualInAllDimension(r, Zero), "resource is not sufficient to do operation: <%v> sub <%v>", r, rr)
 
 	r.MilliCPU -= rr.MilliCPU
 	r.Memory -= rr.Memory
@@ -304,69 +304,38 @@ func (r *Resource) LessInAllDimension(rr *Resource, defaultValue DimensionDefaul
 	return true
 }
 
-// LessEqual works as the same as the LessEqualStrict.
-// The difference is that function lessEqualFunc regards tiny value difference as Equal.
-func (r *Resource) LessEqual(rr *Resource) bool {
+// LessEqualInAllDimension returns true only on condition that all dimensions of resources in r are less than or equal with that of rr,
+// Otherwise returns false.
+// @param defaultValue "default value for resource dimension not defined in ScalarResources. Its value can only be one of 'Zero' and 'Infinity'"
+func (r *Resource) LessEqualInAllDimension(rr *Resource, defaultValue DimensionDefaultValue) bool {
 	lessEqualFunc := func(l, r, diff float64) bool {
 		if l < r || math.Abs(l-r) < diff {
 			return true
 		}
 		return false
 	}
 
-	if !lessEqualFunc(r.MilliCPU, rr.MilliCPU, minResource) {
+	leftResource := r.Clone()
+	rightResource := rr.Clone()
+
+	if !lessEqualFunc(leftResource.MilliCPU, rightResource.MilliCPU, minResource) {
 		return false
 	}
-	if !lessEqualFunc(r.Memory, rr.Memory, minResource) {
+	if !lessEqualFunc(leftResource.Memory, rightResource.Memory, minResource) {
 		return false
 	}
 
-	if r.ScalarResources == nil {
-		return true
-	}
-
-	if rr.ScalarResources == nil {
-		return false
-	}
+	r.setDefaultValue(leftResource, rightResource, defaultValue)
 
-	for rName, rQuant := range r.ScalarResources {
-		if rQuant <= minResource {
+	for resourceName, leftValue := range leftResource.ScalarResources {
+		rightValue, _ := rightResource.ScalarResources[resourceName]
+		if rightValue == -1 {
 			continue
 		}
-		rrQuant, ok := rr.ScalarResources[rName]
-		if !ok || !lessEqualFunc(rQuant, rrQuant, minResource) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// LessEqualStrict returns true only on the following conditions:
-// 1. All dimensions resources in r are less than that of rr
-// 2. Part dimensions are equal while the others are less in r
-// 3. All dimensions resources in r are equal with that of rr
-// Otherwise returns false.
-// Note: Any dimension of resource, which is not listed in resource object, is regarded as zero.
-func (r *Resource) LessEqualStrict(rr *Resource) bool {
-	lessFunc := func(l, r float64) bool {
-		return l <= r
-	}
-
-	if !lessFunc(r.MilliCPU, rr.MilliCPU) {
-		return false
-	}
-	if !lessFunc(r.Memory, rr.Memory) {
-		return false
-	}
-
-	for rName, rQuant := range r.ScalarResources {
-		_, ok := rr.ScalarResources[rName]
-		if !ok || !lessFunc(rQuant, rr.ScalarResources[rName]) {
+		if leftValue == -1 || !lessEqualFunc(leftValue, rightValue, minResource) {
 			return false
 		}
 	}
-
 	return true
 }