diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/util/resource/TestResourceCalculator.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/util/resource/TestResourceCalculator.java new file mode 100644 index 0000000..35c6f73 --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/test/java/org/apache/hadoop/yarn/util/resource/TestResourceCalculator.java @@ -0,0 +1,120 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.yarn.util.resource; + +import java.util.Arrays; +import java.util.Collection; + +import org.apache.hadoop.yarn.api.records.Resource; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class TestResourceCalculator { + private ResourceCalculator resourceCalculator; + + @Parameterized.Parameters + public static Collection getParameters() { + return Arrays.asList(new ResourceCalculator[][] { + { new DefaultResourceCalculator() }, + { new DominantResourceCalculator() } }); + } + + public TestResourceCalculator(ResourceCalculator rs) { + this.resourceCalculator = rs; + } + + @Test + public void testResourceCalculatorCompareMethod() { + Resource clusterResource = Resource.newInstance(0, 0); + + // For lhs == rhs + Resource lhs = Resource.newInstance(0, 0); + Resource rhs = Resource.newInstance(0, 0); + + Assert.assertEquals(false, + Resources.lessThan(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(true, Resources.lessThanOrEqual(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(false, + Resources.greaterThan(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(true, Resources.greaterThanOrEqual(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(lhs, + Resources.max(resourceCalculator, clusterResource, lhs, + rhs)); + + Assert.assertEquals(lhs, + Resources.min(resourceCalculator, clusterResource, lhs, + rhs)); + + // lhs > rhs + lhs = Resource.newInstance(1024, 1); + rhs = Resource.newInstance(0, 0); + + Assert.assertEquals(false, + Resources.lessThan(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(false, Resources.lessThanOrEqual(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(true, + Resources.greaterThan(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(true, Resources.greaterThanOrEqual(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(lhs, + Resources.max(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(rhs, + Resources.min(resourceCalculator, clusterResource, lhs, rhs)); + + // For lhs < rhs + lhs = Resource.newInstance(0, 0); + rhs = Resource.newInstance(1024, 1); + + Assert.assertEquals(true, + Resources.lessThan(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(true, Resources.lessThanOrEqual(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(false, + Resources.greaterThan(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(false, Resources.greaterThanOrEqual(resourceCalculator, + clusterResource, lhs, rhs)); + + Assert.assertEquals(rhs, + Resources.max(resourceCalculator, clusterResource, lhs, rhs)); + + Assert.assertEquals(lhs, + Resources.min(resourceCalculator, clusterResource, lhs, rhs)); + + } + +} diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/util/resource/DominantResourceCalculator.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/util/resource/DominantResourceCalculator.java index 6f5b40e..04cd421 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/util/resource/DominantResourceCalculator.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/util/resource/DominantResourceCalculator.java @@ -56,6 +56,16 @@ public int compare(Resource clusterResource, Resource lhs, Resource rhs) { float l = getResourceAsValue(clusterResource, lhs, true); float r = getResourceAsValue(clusterResource, rhs, true); + if (Float.isNaN(l) && Float.isNaN(r)) { + return 0; + } else if (Float.isNaN(l)) { + return -1; + } else if (Float.isNaN(r)) { + return 1; + } + + // TODO what if both l and r infinity? Should infinity compared? how? + if (l < r) { return -1; } else if (l > r) { @@ -63,6 +73,15 @@ public int compare(Resource clusterResource, Resource lhs, Resource rhs) { } else { l = getResourceAsValue(clusterResource, lhs, false); r = getResourceAsValue(clusterResource, rhs, false); + + if (Float.isNaN(l) && Float.isNaN(r)) { + return 0; + } else if (Float.isNaN(l)) { + return -1; + } else if (Float.isNaN(r)) { + return 1; + } + if (l < r) { return -1; } else if (l > r) { @@ -193,5 +212,4 @@ public Resource multiplyAndNormalizeDown(Resource r, double by, ) ); } - }