http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/policy/PriorityUtilizationQueueOrderingPolicy.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/policy/PriorityUtilizationQueueOrderingPolicy.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/policy/PriorityUtilizationQueueOrderingPolicy.java index 0544387..4985a1a 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/policy/PriorityUtilizationQueueOrderingPolicy.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/policy/PriorityUtilizationQueueOrderingPolicy.java @@ -20,9 +20,11 @@ package org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.policy; import com.google.common.annotations.VisibleForTesting; import org.apache.commons.lang3.StringUtils; +import org.apache.hadoop.yarn.api.records.Resource; import org.apache.hadoop.yarn.server.resourcemanager.nodelabels.RMNodeLabelsManager; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CSQueue; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacitySchedulerConfiguration; +import org.apache.hadoop.yarn.util.resource.Resources; import java.util.ArrayList; import java.util.Collections; @@ -121,6 +123,15 @@ public class PriorityUtilizationQueueOrderingPolicy implements QueueOrderingPoli // For queue with same used ratio / priority, queue with higher configured // capacity goes first if (0 == rc) { + Resource minEffRes1 = q1.getQueueResourceQuotas() + .getConfiguredMinResource(p); + Resource minEffRes2 = q2.getQueueResourceQuotas() + .getConfiguredMinResource(p); + if (!minEffRes1.equals(Resources.none()) + && !minEffRes2.equals(Resources.none())) { + return minEffRes2.compareTo(minEffRes1); + } + float abs1 = q1.getQueueCapacities().getAbsoluteCapacity(p); float abs2 = q2.getQueueCapacities().getAbsoluteCapacity(p); return Float.compare(abs2, abs1);
http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/dao/CapacitySchedulerQueueInfo.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/dao/CapacitySchedulerQueueInfo.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/dao/CapacitySchedulerQueueInfo.java index 22705cc..86b2fea 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/dao/CapacitySchedulerQueueInfo.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/dao/CapacitySchedulerQueueInfo.java @@ -62,6 +62,8 @@ public class CapacitySchedulerQueueInfo { protected long pendingContainers; protected QueueCapacitiesInfo capacities; protected ResourcesInfo resources; + protected ResourceInfo minEffectiveCapacity; + protected ResourceInfo maxEffectiveCapacity; CapacitySchedulerQueueInfo() { }; @@ -105,6 +107,11 @@ public class CapacitySchedulerQueueInfo { ResourceUsage queueResourceUsage = q.getQueueResourceUsage(); populateQueueResourceUsage(queueResourceUsage); + + minEffectiveCapacity = new ResourceInfo( + q.getQueueResourceQuotas().getEffectiveMinResource()); + maxEffectiveCapacity = new ResourceInfo( + q.getQueueResourceQuotas().getEffectiveMaxResource()); } protected void populateQueueResourceUsage(ResourceUsage queueResourceUsage) { @@ -200,4 +207,12 @@ public class CapacitySchedulerQueueInfo { public ResourcesInfo getResources() { return resources; } + + public ResourceInfo getMinEffectiveCapacity(){ + return minEffectiveCapacity; + } + + public ResourceInfo getMaxEffectiveCapacity(){ + return maxEffectiveCapacity; + } } http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockNM.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockNM.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockNM.java index b5c20f4..909d023 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockNM.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockNM.java @@ -41,6 +41,7 @@ import org.apache.hadoop.yarn.server.api.protocolrecords.NodeHeartbeatResponse; import org.apache.hadoop.yarn.server.api.protocolrecords.RegisterNodeManagerRequest; import org.apache.hadoop.yarn.server.api.protocolrecords.RegisterNodeManagerResponse; import org.apache.hadoop.yarn.server.api.records.AppCollectorData; +import org.apache.hadoop.yarn.server.api.protocolrecords.UnRegisterNodeManagerRequest; import org.apache.hadoop.yarn.server.api.records.MasterKey; import org.apache.hadoop.yarn.server.api.records.NodeHealthStatus; import org.apache.hadoop.yarn.server.api.records.NodeStatus; @@ -142,6 +143,13 @@ public class MockNM { return this.registeringCollectors; } + public void unRegisterNode() throws Exception { + UnRegisterNodeManagerRequest request = Records + .newRecord(UnRegisterNodeManagerRequest.class); + request.setNodeId(nodeId); + resourceTracker.unRegisterNodeManager(request); + } + public RegisterNodeManagerResponse registerNode() throws Exception { return registerNode(null, null); } http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockRM.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockRM.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockRM.java index 711f008..19ca6d7 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockRM.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/MockRM.java @@ -823,6 +823,12 @@ public class MockRM extends ResourceManager { return rmApp; } + public MockNM unRegisterNode(MockNM nm) throws Exception { + nm.unRegisterNode(); + drainEventsImplicitly(); + return nm; + } + public MockNM registerNode(String nodeIdStr, int memory) throws Exception { MockNM nm = new MockNM(nodeIdStr, memory, getResourceTrackerService()); nm.registerNode(); http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/ProportionalCapacityPreemptionPolicyMockFramework.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/ProportionalCapacityPreemptionPolicyMockFramework.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/ProportionalCapacityPreemptionPolicyMockFramework.java index 0bc5cb5..1dda8a6 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/ProportionalCapacityPreemptionPolicyMockFramework.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/ProportionalCapacityPreemptionPolicyMockFramework.java @@ -34,6 +34,7 @@ import org.apache.hadoop.yarn.server.resourcemanager.RMContext; import org.apache.hadoop.yarn.server.resourcemanager.nodelabels.RMNodeLabelsManager; import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainerImpl; +import org.apache.hadoop.yarn.server.resourcemanager.scheduler.QueueResourceQuotas; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceUsage; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerNode; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.policy.QueueOrderingPolicy; @@ -644,9 +645,11 @@ public class ProportionalCapacityPreemptionPolicyMockFramework { QueueCapacities qc = new QueueCapacities(0 == myLevel); ResourceUsage ru = new ResourceUsage(); + QueueResourceQuotas qr = new QueueResourceQuotas(); when(queue.getQueueCapacities()).thenReturn(qc); when(queue.getQueueResourceUsage()).thenReturn(ru); + when(queue.getQueueResourceQuotas()).thenReturn(qr); LOG.debug("Setup queue, name=" + queue.getQueueName() + " path=" + queue.getQueuePath()); @@ -679,7 +682,17 @@ public class ProportionalCapacityPreemptionPolicyMockFramework { qc.setAbsoluteMaximumCapacity(partitionName, absMax); qc.setAbsoluteUsedCapacity(partitionName, absUsed); qc.setUsedCapacity(partitionName, used); + qr.setEffectiveMaxResource(parseResourceFromString(values[1].trim())); + qr.setEffectiveMinResource(parseResourceFromString(values[0].trim())); + qr.setEffectiveMaxResource(partitionName, + parseResourceFromString(values[1].trim())); + qr.setEffectiveMinResource(partitionName, + parseResourceFromString(values[0].trim())); when(queue.getUsedCapacity()).thenReturn(used); + when(queue.getEffectiveCapacity(partitionName)) + .thenReturn(parseResourceFromString(values[0].trim())); + when(queue.getEffectiveMaxCapacity(partitionName)) + .thenReturn(parseResourceFromString(values[1].trim())); ru.setPending(partitionName, pending); // Setup reserved resource if it contained by input config Resource reserved = Resources.none(); http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicy.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicy.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicy.java index 694be09..dd950f3 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicy.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicy.java @@ -35,6 +35,7 @@ import org.apache.hadoop.yarn.server.resourcemanager.RMContext; import org.apache.hadoop.yarn.server.resourcemanager.monitor.SchedulingMonitor; import org.apache.hadoop.yarn.server.resourcemanager.nodelabels.RMNodeLabelsManager; import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer; +import org.apache.hadoop.yarn.server.resourcemanager.scheduler.QueueResourceQuotas; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceUsage; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.policy.QueueOrderingPolicy; import org.apache.hadoop.yarn.server.scheduler.SchedulerRequestKey; @@ -48,7 +49,6 @@ import org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.preempti import org.apache.hadoop.yarn.server.resourcemanager.scheduler.common.fica.FiCaSchedulerApp; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.common.fica.FiCaSchedulerNode; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.event.ContainerPreemptEvent; -import org.apache.hadoop.yarn.server.resourcemanager.scheduler.event.SchedulerEvent; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.event.SchedulerEventType; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.policy.OrderingPolicy; import org.apache.hadoop.yarn.util.Clock; @@ -437,8 +437,8 @@ public class TestProportionalCapacityPreemptionPolicy { policy.editSchedule(); // queueF(appD) wants resources, Verify that resources come from queueE(appC) // because it's a sibling and queueB(appA) because queueA is over capacity. - verify(mDisp, times(28)).handle(argThat(new IsPreemptionRequestFor(appA))); - verify(mDisp, times(22)).handle(argThat(new IsPreemptionRequestFor(appC))); + verify(mDisp, times(27)).handle(argThat(new IsPreemptionRequestFor(appA))); + verify(mDisp, times(23)).handle(argThat(new IsPreemptionRequestFor(appC))); // Need to call setup() again to reset mDisp setup(); @@ -1202,6 +1202,17 @@ public class TestProportionalCapacityPreemptionPolicy { when(root.getQueuePath()).thenReturn(CapacitySchedulerConfiguration.ROOT); boolean preemptionDisabled = mockPreemptionStatus("root"); when(root.getPreemptionDisabled()).thenReturn(preemptionDisabled); + QueueResourceQuotas rootQr = new QueueResourceQuotas(); + rootQr.setEffectiveMaxResource(Resource.newInstance(maxCap[0], 0)); + rootQr.setEffectiveMinResource(abs[0]); + rootQr.setEffectiveMaxResource(RMNodeLabelsManager.NO_LABEL, + Resource.newInstance(maxCap[0], 0)); + rootQr.setEffectiveMinResource(RMNodeLabelsManager.NO_LABEL, abs[0]); + when(root.getQueueResourceQuotas()).thenReturn(rootQr); + when(root.getEffectiveCapacity(RMNodeLabelsManager.NO_LABEL)) + .thenReturn(abs[0]); + when(root.getEffectiveMaxCapacity(RMNodeLabelsManager.NO_LABEL)) + .thenReturn(Resource.newInstance(maxCap[0], 0)); for (int i = 1; i < queues.length; ++i) { final CSQueue q; @@ -1232,6 +1243,18 @@ public class TestProportionalCapacityPreemptionPolicy { qc.setAbsoluteMaximumCapacity(maxCap[i] / (float) tot.getMemorySize()); when(q.getQueueCapacities()).thenReturn(qc); + QueueResourceQuotas qr = new QueueResourceQuotas(); + qr.setEffectiveMaxResource(Resource.newInstance(maxCap[i], 0)); + qr.setEffectiveMinResource(abs[i]); + qr.setEffectiveMaxResource(RMNodeLabelsManager.NO_LABEL, + Resource.newInstance(maxCap[i], 0)); + qr.setEffectiveMinResource(RMNodeLabelsManager.NO_LABEL, abs[i]); + when(q.getQueueResourceQuotas()).thenReturn(qr); + when(q.getEffectiveCapacity(RMNodeLabelsManager.NO_LABEL)) + .thenReturn(abs[i]); + when(q.getEffectiveMaxCapacity(RMNodeLabelsManager.NO_LABEL)) + .thenReturn(Resource.newInstance(maxCap[i], 0)); + String parentPathName = p.getQueuePath(); parentPathName = (parentPathName == null) ? "root" : parentPathName; String queuePathName = (parentPathName + "." + queueName).replace("/", http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF.java index 7784549..a1d89d7 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/monitor/capacity/TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF.java @@ -67,9 +67,9 @@ public class TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF conf.set(CapacitySchedulerConfiguration.INTRAQUEUE_PREEMPTION_ORDER_POLICY, "priority_first"); - String labelsConfig = "=100:200,true;"; + String labelsConfig = "=100:50,true;"; String nodesConfig = // n1 has no label - "n1= res=100:200"; + "n1= res=100:50"; String queuesConfig = // guaranteed,max,used,pending,reserved "root(=[100:50 100:50 80:40 120:60 0]);" + // root @@ -105,7 +105,7 @@ public class TestProportionalCapacityPreemptionPolicyIntraQueueWithDRF verify(mDisp, times(1)).handle(argThat( new TestProportionalCapacityPreemptionPolicy.IsPreemptionRequestFor( getAppAttemptId(4)))); - verify(mDisp, times(7)).handle(argThat( + verify(mDisp, times(3)).handle(argThat( new TestProportionalCapacityPreemptionPolicy.IsPreemptionRequestFor( getAppAttemptId(3)))); } http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestAbsoluteResourceConfiguration.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestAbsoluteResourceConfiguration.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestAbsoluteResourceConfiguration.java new file mode 100644 index 0000000..5a66281 --- /dev/null +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestAbsoluteResourceConfiguration.java @@ -0,0 +1,516 @@ +/** +* 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.server.resourcemanager.scheduler.capacity; + +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import org.apache.hadoop.yarn.api.records.Resource; +import org.apache.hadoop.yarn.conf.YarnConfiguration; +import org.apache.hadoop.yarn.server.resourcemanager.MockNM; +import org.apache.hadoop.yarn.server.resourcemanager.MockRM; +import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceScheduler; +import org.apache.hadoop.yarn.util.resource.Resources; +import org.junit.Assert; +import org.junit.Test; + +public class TestAbsoluteResourceConfiguration { + + private static final int GB = 1024; + + private static final String QUEUEA = "queueA"; + private static final String QUEUEB = "queueB"; + private static final String QUEUEC = "queueC"; + private static final String QUEUEA1 = "queueA1"; + private static final String QUEUEA2 = "queueA2"; + private static final String QUEUEB1 = "queueB1"; + + private static final String QUEUEA_FULL = CapacitySchedulerConfiguration.ROOT + + "." + QUEUEA; + private static final String QUEUEB_FULL = CapacitySchedulerConfiguration.ROOT + + "." + QUEUEB; + private static final String QUEUEC_FULL = CapacitySchedulerConfiguration.ROOT + + "." + QUEUEC; + private static final String QUEUEA1_FULL = QUEUEA_FULL + "." + QUEUEA1; + private static final String QUEUEA2_FULL = QUEUEA_FULL + "." + QUEUEA2; + private static final String QUEUEB1_FULL = QUEUEB_FULL + "." + QUEUEB1; + + private static final Resource QUEUE_A_MINRES = Resource.newInstance(100 * GB, + 10); + private static final Resource QUEUE_A_MAXRES = Resource.newInstance(200 * GB, + 30); + private static final Resource QUEUE_A1_MINRES = Resource.newInstance(50 * GB, + 5); + private static final Resource QUEUE_A2_MINRES = Resource.newInstance(50 * GB, + 5); + private static final Resource QUEUE_B_MINRES = Resource.newInstance(50 * GB, + 10); + private static final Resource QUEUE_B1_MINRES = Resource.newInstance(40 * GB, + 10); + private static final Resource QUEUE_B_MAXRES = Resource.newInstance(150 * GB, + 30); + private static final Resource QUEUE_C_MINRES = Resource.newInstance(50 * GB, + 10); + private static final Resource QUEUE_C_MAXRES = Resource.newInstance(150 * GB, + 20); + private static final Resource QUEUEA_REDUCED = Resource.newInstance(64000, 6); + private static final Resource QUEUEB_REDUCED = Resource.newInstance(32000, 6); + private static final Resource QUEUEC_REDUCED = Resource.newInstance(32000, 6); + private static final Resource QUEUEMAX_REDUCED = Resource.newInstance(128000, + 20); + + private static Set<String> resourceTypes = new HashSet<>( + Arrays.asList("memory", "vcores")); + + private CapacitySchedulerConfiguration setupSimpleQueueConfiguration( + boolean isCapacityNeeded) { + CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration(); + csConf.setQueues(CapacitySchedulerConfiguration.ROOT, + new String[]{QUEUEA, QUEUEB, QUEUEC}); + + // Set default capacities like normal configuration. + if (isCapacityNeeded) { + csConf.setCapacity(QUEUEA_FULL, 50f); + csConf.setCapacity(QUEUEB_FULL, 25f); + csConf.setCapacity(QUEUEC_FULL, 25f); + } + + return csConf; + } + + private CapacitySchedulerConfiguration setupComplexQueueConfiguration( + boolean isCapacityNeeded) { + CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration(); + csConf.setQueues(CapacitySchedulerConfiguration.ROOT, + new String[]{QUEUEA, QUEUEB, QUEUEC}); + csConf.setQueues(QUEUEA_FULL, new String[]{QUEUEA1, QUEUEA2}); + csConf.setQueues(QUEUEB_FULL, new String[]{QUEUEB1}); + + // Set default capacities like normal configuration. + if (isCapacityNeeded) { + csConf.setCapacity(QUEUEA_FULL, 50f); + csConf.setCapacity(QUEUEB_FULL, 25f); + csConf.setCapacity(QUEUEC_FULL, 25f); + csConf.setCapacity(QUEUEA1_FULL, 50f); + csConf.setCapacity(QUEUEA2_FULL, 50f); + csConf.setCapacity(QUEUEB1_FULL, 100f); + } + + return csConf; + } + + private CapacitySchedulerConfiguration setupMinMaxResourceConfiguration( + CapacitySchedulerConfiguration csConf) { + // Update min/max resource to queueA/B/C + csConf.setMinimumResourceRequirement("", QUEUEA_FULL, QUEUE_A_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEB_FULL, QUEUE_B_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEC_FULL, QUEUE_C_MINRES); + + csConf.setMaximumResourceRequirement("", QUEUEA_FULL, QUEUE_A_MAXRES); + csConf.setMaximumResourceRequirement("", QUEUEB_FULL, QUEUE_B_MAXRES); + csConf.setMaximumResourceRequirement("", QUEUEC_FULL, QUEUE_C_MAXRES); + + return csConf; + } + + private CapacitySchedulerConfiguration setupComplexMinMaxResourceConfig( + CapacitySchedulerConfiguration csConf) { + // Update min/max resource to queueA/B/C + csConf.setMinimumResourceRequirement("", QUEUEA_FULL, QUEUE_A_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEB_FULL, QUEUE_B_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEC_FULL, QUEUE_C_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEA1_FULL, QUEUE_A1_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEA2_FULL, QUEUE_A2_MINRES); + csConf.setMinimumResourceRequirement("", QUEUEB1_FULL, QUEUE_B1_MINRES); + + csConf.setMaximumResourceRequirement("", QUEUEA_FULL, QUEUE_A_MAXRES); + csConf.setMaximumResourceRequirement("", QUEUEB_FULL, QUEUE_B_MAXRES); + csConf.setMaximumResourceRequirement("", QUEUEC_FULL, QUEUE_C_MAXRES); + + return csConf; + } + + @Test + public void testSimpleMinMaxResourceConfigurartionPerQueue() { + + CapacitySchedulerConfiguration csConf = setupSimpleQueueConfiguration(true); + setupMinMaxResourceConfiguration(csConf); + + Assert.assertEquals("Min resource configured for QUEUEA is not correct", + QUEUE_A_MINRES, + csConf.getMinimumResourceRequirement("", QUEUEA_FULL, resourceTypes)); + Assert.assertEquals("Max resource configured for QUEUEA is not correct", + QUEUE_A_MAXRES, + csConf.getMaximumResourceRequirement("", QUEUEA_FULL, resourceTypes)); + Assert.assertEquals("Min resource configured for QUEUEB is not correct", + QUEUE_B_MINRES, + csConf.getMinimumResourceRequirement("", QUEUEB_FULL, resourceTypes)); + Assert.assertEquals("Max resource configured for QUEUEB is not correct", + QUEUE_B_MAXRES, + csConf.getMaximumResourceRequirement("", QUEUEB_FULL, resourceTypes)); + Assert.assertEquals("Min resource configured for QUEUEC is not correct", + QUEUE_C_MINRES, + csConf.getMinimumResourceRequirement("", QUEUEC_FULL, resourceTypes)); + Assert.assertEquals("Max resource configured for QUEUEC is not correct", + QUEUE_C_MAXRES, + csConf.getMaximumResourceRequirement("", QUEUEC_FULL, resourceTypes)); + } + + @Test + public void testEffectiveMinMaxResourceConfigurartionPerQueue() + throws Exception { + // create conf with basic queue configuration. + CapacitySchedulerConfiguration csConf = setupSimpleQueueConfiguration( + false); + setupMinMaxResourceConfiguration(csConf); + + csConf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class, + ResourceScheduler.class); + + @SuppressWarnings("resource") + MockRM rm = new MockRM(csConf); + rm.start(); + + // Add few nodes + rm.registerNode("127.0.0.1:1234", 250 * GB, 40); + + // Get queue object to verify min/max resource configuration. + CapacityScheduler cs = (CapacityScheduler) rm.getResourceScheduler(); + + LeafQueue qA = (LeafQueue) cs.getQueue(QUEUEA); + Assert.assertNotNull(qA); + Assert.assertEquals("Min resource configured for QUEUEA is not correct", + QUEUE_A_MINRES, qA.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEA is not correct", + QUEUE_A_MAXRES, qA.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEA is not correct", + QUEUE_A_MINRES, qA.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEA is not correct", + QUEUE_A_MAXRES, qA.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qB = (LeafQueue) cs.getQueue(QUEUEB); + Assert.assertNotNull(qB); + Assert.assertEquals("Min resource configured for QUEUEB is not correct", + QUEUE_B_MINRES, qB.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEB is not correct", + QUEUE_B_MAXRES, qB.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEB is not correct", + QUEUE_B_MINRES, qB.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEB is not correct", + QUEUE_B_MAXRES, qB.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qC = (LeafQueue) cs.getQueue(QUEUEC); + Assert.assertNotNull(qC); + Assert.assertEquals("Min resource configured for QUEUEC is not correct", + QUEUE_C_MINRES, qC.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEC is not correct", + QUEUE_C_MAXRES, qC.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEC is not correct", + QUEUE_C_MINRES, qC.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEC is not correct", + QUEUE_C_MAXRES, qC.queueResourceQuotas.getEffectiveMaxResource()); + + rm.stop(); + } + + @Test + public void testSimpleValidateAbsoluteResourceConfig() throws Exception { + /** + * Queue structure is as follows. root / | \ a b c / \ | a1 a2 b1 + * + * Test below cases 1) Configure percentage based capacity and absolute + * resource together. 2) As per above tree structure, ensure all values + * could be retrieved. 3) Validate whether min resource cannot be more than + * max resources. 4) Validate whether max resource of queue cannot be more + * than its parent max resource. + */ + // create conf with basic queue configuration. + CapacitySchedulerConfiguration csConf = setupSimpleQueueConfiguration( + false); + setupMinMaxResourceConfiguration(csConf); + csConf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class, + ResourceScheduler.class); + + @SuppressWarnings("resource") + MockRM rm = new MockRM(csConf); + rm.start(); + + // Add few nodes + rm.registerNode("127.0.0.1:1234", 250 * GB, 40); + + // Get queue object to verify min/max resource configuration. + CapacityScheduler cs = (CapacityScheduler) rm.getResourceScheduler(); + + // 1. Create a new config with capcity and min/max together. Ensure an + // exception is thrown. + CapacitySchedulerConfiguration csConf1 = setupSimpleQueueConfiguration( + true); + setupMinMaxResourceConfiguration(csConf1); + + try { + cs.reinitialize(csConf1, rm.getRMContext()); + Assert.fail(); + } catch (IOException e) { + Assert.assertTrue(e instanceof IOException); + Assert.assertEquals( + "Failed to re-init queues : Queue 'queueA' should use either" + + " percentage based capacity configuration or absolute resource.", + e.getMessage()); + } + rm.stop(); + + // 2. Create a new config with min/max alone with a complex queue config. + // Check all values could be fetched correctly. + CapacitySchedulerConfiguration csConf2 = setupComplexQueueConfiguration( + false); + setupComplexMinMaxResourceConfig(csConf2); + + rm = new MockRM(csConf2); + rm.start(); + rm.registerNode("127.0.0.1:1234", 250 * GB, 40); + cs = (CapacityScheduler) rm.getResourceScheduler(); + + LeafQueue qA1 = (LeafQueue) cs.getQueue(QUEUEA1); + Assert.assertEquals("Effective Min resource for QUEUEA1 is not correct", + QUEUE_A1_MINRES, qA1.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEA1 is not correct", + QUEUE_A_MAXRES, qA1.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qA2 = (LeafQueue) cs.getQueue(QUEUEA2); + Assert.assertEquals("Effective Min resource for QUEUEA2 is not correct", + QUEUE_A2_MINRES, qA2.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEA2 is not correct", + QUEUE_A_MAXRES, qA2.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qB1 = (LeafQueue) cs.getQueue(QUEUEB1); + Assert.assertNotNull(qB1); + Assert.assertEquals("Min resource configured for QUEUEB1 is not correct", + QUEUE_B1_MINRES, qB1.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEB1 is not correct", + QUEUE_B_MAXRES, qB1.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEB1 is not correct", + QUEUE_B1_MINRES, qB1.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEB1 is not correct", + QUEUE_B_MAXRES, qB1.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qC = (LeafQueue) cs.getQueue(QUEUEC); + Assert.assertNotNull(qC); + Assert.assertEquals("Min resource configured for QUEUEC is not correct", + QUEUE_C_MINRES, qC.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEC is not correct", + QUEUE_C_MAXRES, qC.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEC is not correct", + QUEUE_C_MINRES, qC.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEC is not correct", + QUEUE_C_MAXRES, qC.queueResourceQuotas.getEffectiveMaxResource()); + + // 3. Create a new config and make sure one queue's min resource is more + // than its max resource configured. + CapacitySchedulerConfiguration csConf3 = setupComplexQueueConfiguration( + false); + setupComplexMinMaxResourceConfig(csConf3); + + csConf3.setMinimumResourceRequirement("", QUEUEB1_FULL, QUEUE_B_MAXRES); + csConf3.setMaximumResourceRequirement("", QUEUEB1_FULL, QUEUE_B1_MINRES); + + try { + cs.reinitialize(csConf3, rm.getRMContext()); + Assert.fail(); + } catch (IOException e) { + Assert.assertTrue(e instanceof IOException); + Assert.assertEquals( + "Failed to re-init queues : Min resource configuration " + + "<memory:153600, vCores:30> is greater than its " + + "max value:<memory:40960, vCores:10> in queue:queueB1", + e.getMessage()); + } + + // 4. Create a new config and make sure one queue's max resource is more + // than its preant's max resource configured. + CapacitySchedulerConfiguration csConf4 = setupComplexQueueConfiguration( + false); + setupComplexMinMaxResourceConfig(csConf4); + + csConf4.setMaximumResourceRequirement("", QUEUEB1_FULL, QUEUE_A_MAXRES); + + try { + cs.reinitialize(csConf4, rm.getRMContext()); + Assert.fail(); + } catch (IOException e) { + Assert.assertTrue(e instanceof IOException); + Assert + .assertEquals( + "Failed to re-init queues : Max resource configuration " + + "<memory:204800, vCores:30> is greater than parents max value:" + + "<memory:153600, vCores:30> in queue:queueB1", + e.getMessage()); + } + rm.stop(); + } + + @Test + public void testComplexValidateAbsoluteResourceConfig() throws Exception { + /** + * Queue structure is as follows. root / | \ a b c / \ | a1 a2 b1 + * + * Test below cases: 1) Parent and its child queues must use either + * percentage based or absolute resource configuration. 2) Parent's min + * resource must be more than sum of child's min resource. + */ + + // create conf with basic queue configuration. + CapacitySchedulerConfiguration csConf = setupComplexQueueConfiguration( + false); + setupComplexMinMaxResourceConfig(csConf); + csConf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class, + ResourceScheduler.class); + + @SuppressWarnings("resource") + MockRM rm = new MockRM(csConf); + rm.start(); + + // Add few nodes + rm.registerNode("127.0.0.1:1234", 250 * GB, 40); + + // 1. Explicitly set percentage based config for parent queues. This will + // make Queue A,B and C with percentage based and A1,A2 or B1 with absolute + // resource. + csConf.setCapacity(QUEUEA_FULL, 50f); + csConf.setCapacity(QUEUEB_FULL, 25f); + csConf.setCapacity(QUEUEC_FULL, 25f); + + // Also unset resource based config. + csConf.setMinimumResourceRequirement("", QUEUEA_FULL, Resources.none()); + csConf.setMinimumResourceRequirement("", QUEUEB_FULL, Resources.none()); + csConf.setMinimumResourceRequirement("", QUEUEC_FULL, Resources.none()); + + // Get queue object to verify min/max resource configuration. + CapacityScheduler cs = (CapacityScheduler) rm.getResourceScheduler(); + try { + cs.reinitialize(csConf, rm.getRMContext()); + Assert.fail(); + } catch (IOException e) { + Assert.assertTrue(e instanceof IOException); + Assert.assertEquals( + "Failed to re-init queues : Parent queue 'queueA' " + + "and child queue 'queueA1' should use either percentage based" + + " capacity configuration or absolute resource together.", + e.getMessage()); + } + + // 2. Create a new config and make sure one queue's min resource is more + // than its max resource configured. + CapacitySchedulerConfiguration csConf1 = setupComplexQueueConfiguration( + false); + setupComplexMinMaxResourceConfig(csConf1); + + // Configure QueueA with lesser resource than its children. + csConf1.setMinimumResourceRequirement("", QUEUEA_FULL, QUEUE_A1_MINRES); + + try { + cs.reinitialize(csConf1, rm.getRMContext()); + Assert.fail(); + } catch (IOException e) { + Assert.assertTrue(e instanceof IOException); + Assert.assertEquals("Failed to re-init queues : Parent Queues capacity: " + + "<memory:51200, vCores:5> is less than to its children:" + + "<memory:102400, vCores:10> for queue:queueA", e.getMessage()); + } + } + + @Test + public void testEffectiveResourceAfterReducingClusterResource() + throws Exception { + // create conf with basic queue configuration. + CapacitySchedulerConfiguration csConf = setupSimpleQueueConfiguration( + false); + setupMinMaxResourceConfiguration(csConf); + + csConf.setClass(YarnConfiguration.RM_SCHEDULER, CapacityScheduler.class, + ResourceScheduler.class); + + @SuppressWarnings("resource") + MockRM rm = new MockRM(csConf); + rm.start(); + + // Add few nodes + MockNM nm1 = rm.registerNode("127.0.0.1:1234", 125 * GB, 20); + rm.registerNode("127.0.0.2:1234", 125 * GB, 20); + + // Get queue object to verify min/max resource configuration. + CapacityScheduler cs = (CapacityScheduler) rm.getResourceScheduler(); + + LeafQueue qA = (LeafQueue) cs.getQueue(QUEUEA); + Assert.assertNotNull(qA); + Assert.assertEquals("Min resource configured for QUEUEA is not correct", + QUEUE_A_MINRES, qA.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEA is not correct", + QUEUE_A_MAXRES, qA.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEA is not correct", + QUEUE_A_MINRES, qA.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEA is not correct", + QUEUE_A_MAXRES, qA.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qB = (LeafQueue) cs.getQueue(QUEUEB); + Assert.assertNotNull(qB); + Assert.assertEquals("Min resource configured for QUEUEB is not correct", + QUEUE_B_MINRES, qB.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEB is not correct", + QUEUE_B_MAXRES, qB.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEB is not correct", + QUEUE_B_MINRES, qB.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEB is not correct", + QUEUE_B_MAXRES, qB.queueResourceQuotas.getEffectiveMaxResource()); + + LeafQueue qC = (LeafQueue) cs.getQueue(QUEUEC); + Assert.assertNotNull(qC); + Assert.assertEquals("Min resource configured for QUEUEC is not correct", + QUEUE_C_MINRES, qC.queueResourceQuotas.getConfiguredMinResource()); + Assert.assertEquals("Max resource configured for QUEUEC is not correct", + QUEUE_C_MAXRES, qC.queueResourceQuotas.getConfiguredMaxResource()); + Assert.assertEquals("Effective Min resource for QUEUEC is not correct", + QUEUE_C_MINRES, qC.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEC is not correct", + QUEUE_C_MAXRES, qC.queueResourceQuotas.getEffectiveMaxResource()); + + // unregister one NM. + rm.unRegisterNode(nm1); + + // After loosing one NM, effective min res of queueA will become just + // above half. Hence A's min will be 60Gi and 6 cores and max will be + // 128GB and 20 cores. + Assert.assertEquals("Effective Min resource for QUEUEA is not correct", + QUEUEA_REDUCED, qA.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEA is not correct", + QUEUEMAX_REDUCED, qA.queueResourceQuotas.getEffectiveMaxResource()); + + Assert.assertEquals("Effective Min resource for QUEUEB is not correct", + QUEUEB_REDUCED, qB.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEB is not correct", + QUEUEMAX_REDUCED, qB.queueResourceQuotas.getEffectiveMaxResource()); + + Assert.assertEquals("Effective Min resource for QUEUEC is not correct", + QUEUEC_REDUCED, qC.queueResourceQuotas.getEffectiveMinResource()); + Assert.assertEquals("Effective Max resource for QUEUEC is not correct", + QUEUEMAX_REDUCED, qC.queueResourceQuotas.getEffectiveMaxResource()); + + rm.stop(); + } +} http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimits.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimits.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimits.java index 8aca235..24ae244 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimits.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimits.java @@ -60,6 +60,7 @@ import org.apache.hadoop.yarn.server.resourcemanager.rmapp.RMApp; import org.apache.hadoop.yarn.server.resourcemanager.rmapp.RMAppState; import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.RMAppAttempt; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ActiveUsersManager; +import org.apache.hadoop.yarn.server.resourcemanager.scheduler.QueueResourceQuotas; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceLimits; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceScheduler; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceUsage; @@ -86,6 +87,7 @@ public class TestApplicationLimits { final static int GB = 1024; LeafQueue queue; + CSQueue root; private final ResourceCalculator resourceCalculator = new DefaultResourceCalculator(); @@ -100,7 +102,7 @@ public class TestApplicationLimits { setupQueueConfiguration(csConf); rmContext = TestUtils.getMockRMContext(); - + Resource clusterResource = Resources.createResource(10 * 16 * GB, 10 * 32); CapacitySchedulerContext csContext = mock(CapacitySchedulerContext.class); when(csContext.getConfiguration()).thenReturn(csConf); @@ -110,10 +112,11 @@ public class TestApplicationLimits { when(csContext.getMaximumResourceCapability()). thenReturn(Resources.createResource(16*GB, 32)); when(csContext.getClusterResource()). - thenReturn(Resources.createResource(10 * 16 * GB, 10 * 32)); + thenReturn(clusterResource); when(csContext.getResourceCalculator()). thenReturn(resourceCalculator); when(csContext.getRMContext()).thenReturn(rmContext); + when(csContext.getPreemptionManager()).thenReturn(new PreemptionManager()); RMContainerTokenSecretManager containerTokenSecretManager = new RMContainerTokenSecretManager(conf); @@ -122,13 +125,17 @@ public class TestApplicationLimits { containerTokenSecretManager); Map<String, CSQueue> queues = new HashMap<String, CSQueue>(); - CSQueue root = CapacitySchedulerQueueManager + root = CapacitySchedulerQueueManager .parseQueue(csContext, csConf, null, "root", queues, queues, TestUtils.spyHook); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); - queue = spy(new LeafQueue(csContext, A, root, null)); + QueueResourceQuotas queueResourceQuotas = ((LeafQueue) queues.get(A)) + .getQueueResourceQuotas(); + doReturn(queueResourceQuotas).when(queue).getQueueResourceQuotas(); // Stub out ACL checks doReturn(true). @@ -189,6 +196,8 @@ public class TestApplicationLimits { // when there is only 1 user, and drops to 2G (the userlimit) when there // is a second user Resource clusterResource = Resource.newInstance(80 * GB, 40); + root.updateClusterResource(clusterResource, new ResourceLimits( + clusterResource)); queue.updateClusterResource(clusterResource, new ResourceLimits( clusterResource)); @@ -287,6 +296,8 @@ public class TestApplicationLimits { CSQueue root = CapacitySchedulerQueueManager.parseQueue(csContext, csConf, null, "root", queues, queues, TestUtils.spyHook); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); LeafQueue queue = (LeafQueue)queues.get(A); @@ -357,6 +368,8 @@ public class TestApplicationLimits { csContext, csConf, null, "root", queues, queues, TestUtils.spyHook); clusterResource = Resources.createResource(100 * 16 * GB); + root.updateClusterResource(clusterResource, new ResourceLimits( + clusterResource)); queue = (LeafQueue)queues.get(A); @@ -378,6 +391,8 @@ public class TestApplicationLimits { root = CapacitySchedulerQueueManager.parseQueue( csContext, csConf, null, "root", queues, queues, TestUtils.spyHook); + root.updateClusterResource(clusterResource, new ResourceLimits( + clusterResource)); queue = (LeafQueue)queues.get(A); assertEquals(9999, (int)csConf.getMaximumApplicationsPerQueue(queue.getQueuePath())); @@ -393,7 +408,7 @@ public class TestApplicationLimits { final String user_0 = "user_0"; final String user_1 = "user_1"; final String user_2 = "user_2"; - + assertEquals(Resource.newInstance(16 * GB, 1), queue.calculateAndGetAMResourceLimit()); assertEquals(Resource.newInstance(8 * GB, 1), @@ -578,6 +593,7 @@ public class TestApplicationLimits { thenReturn(Resources.createResource(16*GB)); when(csContext.getResourceCalculator()).thenReturn(resourceCalculator); when(csContext.getRMContext()).thenReturn(rmContext); + when(csContext.getPreemptionManager()).thenReturn(new PreemptionManager()); // Say cluster has 100 nodes of 16G each Resource clusterResource = Resources.createResource(100 * 16 * GB); @@ -586,6 +602,8 @@ public class TestApplicationLimits { Map<String, CSQueue> queues = new HashMap<String, CSQueue>(); CSQueue rootQueue = CapacitySchedulerQueueManager.parseQueue(csContext, csConf, null, "root", queues, queues, TestUtils.spyHook); + rootQueue.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); ResourceUsage queueCapacities = rootQueue.getQueueResourceUsage(); when(csContext.getClusterResourceUsage()) @@ -693,6 +711,8 @@ public class TestApplicationLimits { // Now reduce cluster size and check for the smaller headroom clusterResource = Resources.createResource(90*16*GB); + rootQueue.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Any change is cluster resource needs to enforce user-limit recomputation. // In existing code, LeafQueue#updateClusterResource handled this. However http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimitsByPartition.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimitsByPartition.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimitsByPartition.java index 0aac2ef..d73f1c8 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimitsByPartition.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestApplicationLimitsByPartition.java @@ -54,6 +54,7 @@ import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceLimits; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceScheduler; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceUsage; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.SchedulerApplicationAttempt.AMState; +import org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.preemption.PreemptionManager; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.common.fica.FiCaSchedulerApp; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.common.fica.FiCaSchedulerNode; import org.apache.hadoop.yarn.util.resource.DefaultResourceCalculator; @@ -600,6 +601,7 @@ public class TestApplicationLimitsByPartition { RMContext spyRMContext = spy(rmContext); when(spyRMContext.getNodeLabelManager()).thenReturn(mgr); when(csContext.getRMContext()).thenReturn(spyRMContext); + when(csContext.getPreemptionManager()).thenReturn(new PreemptionManager()); mgr.activateNode(NodeId.newInstance("h0", 0), Resource.newInstance(160 * GB, 16)); // default Label @@ -615,6 +617,8 @@ public class TestApplicationLimitsByPartition { Map<String, CSQueue> queues = new HashMap<String, CSQueue>(); CSQueue rootQueue = CapacitySchedulerQueueManager.parseQueue(csContext, csConf, null, "root", queues, queues, TestUtils.spyHook); + rootQueue.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); ResourceUsage queueResUsage = rootQueue.getQueueResourceUsage(); when(csContext.getClusterResourceUsage()) http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacityScheduler.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacityScheduler.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacityScheduler.java index 1edb0da..ebc5174 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacityScheduler.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacityScheduler.java @@ -4306,7 +4306,7 @@ public class TestCapacityScheduler { null, null, NULL_UPDATE_REQUESTS); CapacityScheduler.schedule(cs); } - assertEquals("P2 Used Resource should be 8 GB", 8 * GB, + assertEquals("P2 Used Resource should be 7 GB", 7 * GB, cs.getQueue("p2").getUsedResources().getMemorySize()); //Free a container from X1 http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestChildQueueOrder.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestChildQueueOrder.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestChildQueueOrder.java index 0fcc86d..fcfa0dd 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestChildQueueOrder.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestChildQueueOrder.java @@ -242,6 +242,8 @@ public class TestChildQueueOrder { Resources.createResource(numNodes * (memoryPerNode*GB), numNodes * coresPerNode); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Start testing CSQueue a = queues.get(A); http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestLeafQueue.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestLeafQueue.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestLeafQueue.java index a32352b..96f8970 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestLeafQueue.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestLeafQueue.java @@ -191,6 +191,8 @@ public class TestLeafQueue { CapacitySchedulerConfiguration.ROOT, queues, queues, TestUtils.spyHook); + root.updateClusterResource(Resources.createResource(100 * 16 * GB, 100 * 32), + new ResourceLimits(Resources.createResource(100 * 16 * GB, 100 * 32))); ResourceUsage queueResUsage = root.getQueueResourceUsage(); when(csContext.getClusterResourceUsage()) @@ -307,13 +309,11 @@ public class TestLeafQueue { // Verify the value for getAMResourceLimit for queues with < .1 maxcap Resource clusterResource = Resource.newInstance(50 * GB, 50); - a.updateClusterResource(clusterResource, + root.updateClusterResource(clusterResource, new ResourceLimits(clusterResource)); assertEquals(Resource.newInstance(1 * GB, 1), a.calculateAndGetAMResourceLimit()); - b.updateClusterResource(clusterResource, - new ResourceLimits(clusterResource)); assertEquals(Resource.newInstance(5 * GB, 1), b.calculateAndGetAMResourceLimit()); } @@ -358,6 +358,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priority = TestUtils.createMockPriority(1); @@ -556,6 +558,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priority = TestUtils.createMockPriority(1); @@ -630,6 +634,8 @@ public class TestLeafQueue { // Test max-capacity // Now - no more allocs since we are at max-cap a.setMaxCapacity(0.5f); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); applyCSAssignment(clusterResource, a.assignContainers(clusterResource, node_0, new ResourceLimits(clusterResource), @@ -699,6 +705,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (80 * GB), numNodes * 100); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Set user-limit. Need a small queue within a large cluster. b.setUserLimit(50); @@ -779,6 +787,8 @@ public class TestLeafQueue { Resources.createResource(numNodes * (8 * GB), numNodes * 100); when(csContext.getNumClusterNodes()).thenReturn(numNodes); when(csContext.getClusterResource()).thenReturn(clusterResource); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests so that one application is memory dominant // and other application is vcores dominant @@ -891,6 +901,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priority = TestUtils.createMockPriority(1); @@ -915,6 +927,8 @@ public class TestLeafQueue { // Set user-limit a.setUserLimit(50); a.setUserLimitFactor(2); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // There're two active users assertEquals(2, a.getAbstractUsersManager().getNumActiveUsers()); @@ -940,7 +954,7 @@ public class TestLeafQueue { assertEquals(1*GB, app_1.getCurrentConsumption().getMemorySize()); // Allocate one container to app_0, before allocating this container, - // user-limit = ceil((4 + 1) / 2) = 3G. app_0's used resource (3G) <= + // user-limit = floor((5 + 1) / 2) = 3G. app_0's used resource (3G) <= // user-limit. applyCSAssignment(clusterResource, a.assignContainers(clusterResource, node_1, @@ -1068,15 +1082,9 @@ public class TestLeafQueue { a.assignContainers(clusterResource, node_1, new ResourceLimits(clusterResource), SchedulingMode.RESPECT_PARTITION_EXCLUSIVITY), a, nodes, apps); - assertEquals(9*GB, a.getUsedResources().getMemorySize()); - assertEquals(8*GB, app_0.getCurrentConsumption().getMemorySize()); - assertEquals(1*GB, app_1.getCurrentConsumption().getMemorySize()); - - assertEquals(4*GB, - app_0.getTotalPendingRequestsPerPartition().get("").getMemorySize()); - - assertEquals(1*GB, - app_1.getTotalPendingRequestsPerPartition().get("").getMemorySize()); + assertEquals(12*GB, a.getUsedResources().getMemorySize()); + assertEquals(12*GB, app_0.getCurrentConsumption().getMemorySize()); + assertEquals(0*GB, app_1.getCurrentConsumption().getMemorySize()); } @SuppressWarnings({ "unchecked", "rawtypes" }) @@ -1100,6 +1108,8 @@ public class TestLeafQueue { final int numNodes = 2; Resource clusterResource = Resources.createResource(numNodes * (8*GB), 1); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); CapacitySchedulerQueueManager mockCapacitySchedulerQueueManager = mock(CapacitySchedulerQueueManager.class); @@ -1122,6 +1132,8 @@ public class TestLeafQueue { qb.setUserLimit(100); qb.setUserLimitFactor(1); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); final ApplicationAttemptId appAttemptId_0 = TestUtils.getMockApplicationAttemptId(0, 0); FiCaSchedulerApp app_0 = @@ -1256,106 +1268,6 @@ public class TestLeafQueue { } @Test - public void testUserHeadroomMultiApp() throws Exception { - // Mock the queue - LeafQueue a = stubLeafQueue((LeafQueue)queues.get(A)); - //unset maxCapacity - a.setMaxCapacity(1.0f); - - // Users - final String user_0 = "user_0"; - final String user_1 = "user_1"; - - // Submit applications - final ApplicationAttemptId appAttemptId_0 = - TestUtils.getMockApplicationAttemptId(0, 0); - FiCaSchedulerApp app_0 = - new FiCaSchedulerApp(appAttemptId_0, user_0, a, - a.getAbstractUsersManager(), spyRMContext); - a.submitApplicationAttempt(app_0, user_0); - - final ApplicationAttemptId appAttemptId_1 = - TestUtils.getMockApplicationAttemptId(1, 0); - FiCaSchedulerApp app_1 = - new FiCaSchedulerApp(appAttemptId_1, user_0, a, - a.getAbstractUsersManager(), spyRMContext); - a.submitApplicationAttempt(app_1, user_0); // same user - - final ApplicationAttemptId appAttemptId_2 = - TestUtils.getMockApplicationAttemptId(2, 0); - FiCaSchedulerApp app_2 = - new FiCaSchedulerApp(appAttemptId_2, user_1, a, - a.getAbstractUsersManager(), spyRMContext); - a.submitApplicationAttempt(app_2, user_1); - - // Setup some nodes - String host_0 = "127.0.0.1"; - FiCaSchedulerNode node_0 = TestUtils.getMockNode(host_0, DEFAULT_RACK, - 0, 16*GB); - String host_1 = "127.0.0.2"; - FiCaSchedulerNode node_1 = TestUtils.getMockNode(host_1, DEFAULT_RACK, - 0, 16*GB); - - Map<ApplicationAttemptId, FiCaSchedulerApp> apps = ImmutableMap.of( - app_0.getApplicationAttemptId(), app_0, app_1.getApplicationAttemptId(), - app_1, app_2.getApplicationAttemptId(), app_2); - Map<NodeId, FiCaSchedulerNode> nodes = ImmutableMap.of(node_0.getNodeID(), - node_0, node_1.getNodeID(), node_1); - - final int numNodes = 2; - Resource clusterResource = Resources.createResource(numNodes * (16*GB), 1); - when(csContext.getNumClusterNodes()).thenReturn(numNodes); - - Priority priority = TestUtils.createMockPriority(1); - - app_0.updateResourceRequests(Collections.singletonList( - TestUtils.createResourceRequest(ResourceRequest.ANY, 1*GB, 1, true, - priority, recordFactory))); - - applyCSAssignment(clusterResource, - a.assignContainers(clusterResource, node_0, - new ResourceLimits(clusterResource), - SchedulingMode.RESPECT_PARTITION_EXCLUSIVITY), a, nodes, apps); - assertEquals(1*GB, a.getUsedResources().getMemorySize()); - assertEquals(1*GB, app_0.getCurrentConsumption().getMemorySize()); - assertEquals(0*GB, app_1.getCurrentConsumption().getMemorySize()); - //Now, headroom is the same for all apps for a given user + queue combo - //and a change to any app's headroom is reflected for all the user's apps - //once those apps are active/have themselves calculated headroom for - //allocation at least one time - assertEquals(2*GB, app_0.getHeadroom().getMemorySize()); - assertEquals(0*GB, app_1.getHeadroom().getMemorySize());//not yet active - assertEquals(0*GB, app_2.getHeadroom().getMemorySize());//not yet active - - app_1.updateResourceRequests(Collections.singletonList( - TestUtils.createResourceRequest(ResourceRequest.ANY, 1*GB, 2, true, - priority, recordFactory))); - - applyCSAssignment(clusterResource, - a.assignContainers(clusterResource, node_0, - new ResourceLimits(clusterResource), - SchedulingMode.RESPECT_PARTITION_EXCLUSIVITY), a, nodes, apps); - assertEquals(2*GB, a.getUsedResources().getMemorySize()); - assertEquals(1*GB, app_0.getCurrentConsumption().getMemorySize()); - assertEquals(1*GB, app_1.getCurrentConsumption().getMemorySize()); - assertEquals(1*GB, app_0.getHeadroom().getMemorySize()); - assertEquals(1*GB, app_1.getHeadroom().getMemorySize());//now active - assertEquals(0*GB, app_2.getHeadroom().getMemorySize());//not yet active - - //Complete container and verify that headroom is updated, for both apps - //for the user - RMContainer rmContainer = app_0.getLiveContainers().iterator().next(); - a.completedContainer(clusterResource, app_0, node_0, rmContainer, - ContainerStatus.newInstance(rmContainer.getContainerId(), - ContainerState.COMPLETE, "", - ContainerExitStatus.KILLED_BY_RESOURCEMANAGER), - RMContainerEventType.KILL, null, true); - - assertEquals(2*GB, app_0.getHeadroom().getMemorySize()); - assertEquals(2*GB, app_1.getHeadroom().getMemorySize()); - } - - @Test public void testHeadroomWithMaxCap() throws Exception { // Mock the queue LeafQueue a = stubLeafQueue((LeafQueue)queues.get(A)); @@ -1403,7 +1315,12 @@ public class TestLeafQueue { final int numNodes = 2; Resource clusterResource = Resources.createResource(numNodes * (8*GB), 1); when(csContext.getNumClusterNodes()).thenReturn(numNodes); - + + ParentQueue root = (ParentQueue) queues + .get(CapacitySchedulerConfiguration.ROOT); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); + // Setup resource-requests Priority priority = TestUtils.createMockPriority(1); app_0.updateResourceRequests(Collections.singletonList( @@ -1454,6 +1371,8 @@ public class TestLeafQueue { // Submit requests for app_1 and set max-cap a.setMaxCapacity(.1f); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); app_2.updateResourceRequests(Collections.singletonList( TestUtils.createResourceRequest(ResourceRequest.ANY, 1*GB, 1, true, priority, recordFactory))); @@ -1542,6 +1461,8 @@ public class TestLeafQueue { Resources.createResource(numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); when(csContext.getClusterResource()).thenReturn(clusterResource); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priority = TestUtils.createMockPriority(1); @@ -1624,6 +1545,8 @@ public class TestLeafQueue { // Test max-capacity // Now - no more allocs since we are at max-cap a.setMaxCapacity(0.5f); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); applyCSAssignment(clusterResource, a.assignContainers(clusterResource, node_0, new ResourceLimits(clusterResource), @@ -1638,6 +1561,8 @@ public class TestLeafQueue { // Now, allocations should goto app_3 since it's under user-limit a.setMaxCapacity(1.0f); a.setUserLimitFactor(1); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); applyCSAssignment(clusterResource, a.assignContainers(clusterResource, node_0, new ResourceLimits(clusterResource), @@ -1743,6 +1668,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (4*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priority = TestUtils.createMockPriority(1); @@ -1880,6 +1807,8 @@ public class TestLeafQueue { final int numNodes = 3; Resource clusterResource = Resources.createResource(numNodes * (4*GB), numNodes * 16); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); when(csContext.getMaximumResourceCapability()).thenReturn( Resources.createResource(4*GB, 16)); @@ -2051,6 +1980,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests and submit Priority priority = TestUtils.createMockPriority(1); @@ -2237,11 +2168,10 @@ public class TestLeafQueue { CSQueue newRoot = CapacitySchedulerQueueManager.parseQueue(csContext, csConf, null, CapacitySchedulerConfiguration.ROOT, newQueues, queues, TestUtils.spyHook); - queues = newQueues; root.reinitialize(newRoot, cs.getClusterResource()); // Manipulate queue 'b' - LeafQueue a = stubLeafQueue((LeafQueue) queues.get(B)); + LeafQueue a = stubLeafQueue((LeafQueue) newQueues.get(B)); // Check locality parameters. assertEquals(2, a.getNodeLocalityDelay()); @@ -2277,6 +2207,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8 * GB), numNodes * 16); when(spyRMContext.getScheduler().getNumClusterNodes()).thenReturn(numNodes); + newRoot.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests and submit Priority priority = TestUtils.createMockPriority(1); @@ -2412,6 +2344,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8*GB), 1); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests and submit List<ResourceRequest> app_0_requests_0 = new ArrayList<ResourceRequest>(); @@ -2545,6 +2479,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource( numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests and submit Priority priority = TestUtils.createMockPriority(1); @@ -2660,17 +2596,14 @@ public class TestLeafQueue { assertEquals(2, e.getNumActiveApplications()); assertEquals(1, e.getNumPendingApplications()); - csConf.setDouble(CapacitySchedulerConfiguration - .MAXIMUM_APPLICATION_MASTERS_RESOURCE_PERCENT, - CapacitySchedulerConfiguration - .DEFAULT_MAXIMUM_APPLICATIONMASTERS_RESOURCE_PERCENT * 2); + csConf.setDouble( + CapacitySchedulerConfiguration.MAXIMUM_APPLICATION_MASTERS_RESOURCE_PERCENT, + CapacitySchedulerConfiguration.DEFAULT_MAXIMUM_APPLICATIONMASTERS_RESOURCE_PERCENT + * 2); Map<String, CSQueue> newQueues = new HashMap<String, CSQueue>(); - CSQueue newRoot = - CapacitySchedulerQueueManager.parseQueue(csContext, csConf, null, - CapacitySchedulerConfiguration.ROOT, - newQueues, queues, - TestUtils.spyHook); - queues = newQueues; + CSQueue newRoot = CapacitySchedulerQueueManager.parseQueue(csContext, + csConf, null, CapacitySchedulerConfiguration.ROOT, newQueues, queues, + TestUtils.spyHook); root.reinitialize(newRoot, csContext.getClusterResource()); // after reinitialization @@ -2697,7 +2630,6 @@ public class TestLeafQueue { CapacitySchedulerConfiguration.ROOT, newQueues, queues, TestUtils.spyHook); - queues = newQueues; root.reinitialize(newRoot, cs.getClusterResource()); // after reinitialization @@ -2745,7 +2677,7 @@ public class TestLeafQueue { assertEquals(1, e.getNumPendingApplications()); Resource clusterResource = Resources.createResource(200 * 16 * GB, 100 * 32); - e.updateClusterResource(clusterResource, + root.updateClusterResource(clusterResource, new ResourceLimits(clusterResource)); // after updating cluster resource @@ -2837,6 +2769,9 @@ public class TestLeafQueue { numNodes * (8*GB), numNodes * 1); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); + // Setup resource-requests // resourceName: <priority, memory, #containers, relaxLocality> // host_0_0: < 1, 1GB, 1, true > @@ -3036,36 +2971,44 @@ public class TestLeafQueue { @Test public void testMaxAMResourcePerQueuePercentAfterQueueRefresh() throws Exception { + Map<String, CSQueue> queues = new HashMap<String, CSQueue>(); CapacitySchedulerConfiguration csConf = new CapacitySchedulerConfiguration(); - Resource clusterResource = Resources - .createResource(100 * 16 * GB, 100 * 32); + final String newRootName = "root" + System.currentTimeMillis(); + setupQueueConfiguration(csConf, newRootName); + + Resource clusterResource = Resources.createResource(100 * 16 * GB, + 100 * 32); CapacitySchedulerContext csContext = mockCSContext(csConf, clusterResource); when(csContext.getRMContext()).thenReturn(rmContext); - csConf.setFloat(CapacitySchedulerConfiguration. - MAXIMUM_APPLICATION_MASTERS_RESOURCE_PERCENT, 0.1f); - ParentQueue root = new ParentQueue(csContext, - CapacitySchedulerConfiguration.ROOT, null, null); - csConf.setCapacity(CapacitySchedulerConfiguration.ROOT + "." + A, 80); - LeafQueue a = new LeafQueue(csContext, A, root, null); - assertEquals(0.1f, a.getMaxAMResourcePerQueuePercent(), 1e-3f); - assertEquals(a.calculateAndGetAMResourceLimit(), - Resources.createResource(160 * GB, 1)); - - csConf.setFloat(CapacitySchedulerConfiguration. - MAXIMUM_APPLICATION_MASTERS_RESOURCE_PERCENT, 0.2f); - LeafQueue newA = new LeafQueue(csContext, A, root, null); - a.reinitialize(newA, clusterResource); - assertEquals(0.2f, a.getMaxAMResourcePerQueuePercent(), 1e-3f); - assertEquals(a.calculateAndGetAMResourceLimit(), - Resources.createResource(320 * GB, 1)); + csConf.setFloat( + CapacitySchedulerConfiguration.MAXIMUM_APPLICATION_MASTERS_RESOURCE_PERCENT, + 0.1f); + + CSQueue root; + root = CapacitySchedulerQueueManager.parseQueue(csContext, csConf, null, + CapacitySchedulerConfiguration.ROOT, queues, queues, TestUtils.spyHook); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); - Resource newClusterResource = Resources.createResource(100 * 20 * GB, - 100 * 32); - a.updateClusterResource(newClusterResource, - new ResourceLimits(newClusterResource)); - // 100 * 20 * 0.2 = 400 - assertEquals(a.calculateAndGetAMResourceLimit(), - Resources.createResource(400 * GB, 1)); + // Manipulate queue 'a' + LeafQueue b = stubLeafQueue((LeafQueue) queues.get(B)); + assertEquals(0.1f, b.getMaxAMResourcePerQueuePercent(), 1e-3f); + assertEquals(b.calculateAndGetAMResourceLimit(), + Resources.createResource(159 * GB, 1)); + + csConf.setFloat( + CapacitySchedulerConfiguration.MAXIMUM_APPLICATION_MASTERS_RESOURCE_PERCENT, + 0.2f); + clusterResource = Resources.createResource(100 * 20 * GB, 100 * 32); + Map<String, CSQueue> newQueues = new HashMap<String, CSQueue>(); + CSQueue newRoot = CapacitySchedulerQueueManager.parseQueue(csContext, + csConf, null, CapacitySchedulerConfiguration.ROOT, newQueues, queues, + TestUtils.spyHook); + root.reinitialize(newRoot, clusterResource); + + b = stubLeafQueue((LeafQueue) newQueues.get(B)); + assertEquals(b.calculateAndGetAMResourceLimit(), + Resources.createResource(320 * GB, 1)); } @Test @@ -3142,6 +3085,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (16 * GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); String user_0 = "user_0"; @@ -3308,6 +3253,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource( numNodes * (16*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); String user_0 = "user_0"; @@ -3435,6 +3382,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (8*GB), numNodes * 16); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests and submit // App0 has node local request for host_0/host_1, and app1 has node local @@ -3533,6 +3482,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (100*GB), numNodes * 128); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Pending resource requests for app_0 and app_1 total 5GB. Priority priority = TestUtils.createMockPriority(1); @@ -3699,6 +3650,8 @@ public class TestLeafQueue { Resource clusterResource = Resources.createResource(numNodes * (100*GB), numNodes * 128); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Pending resource requests for user_0: app_0 and app_1 total 3GB. Priority priority = TestUtils.createMockPriority(1); http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestParentQueue.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestParentQueue.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestParentQueue.java index a9196d1..25a9774 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestParentQueue.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestParentQueue.java @@ -249,6 +249,8 @@ public class TestParentQueue { Resources.createResource(numNodes * (memoryPerNode*GB), numNodes * coresPerNode); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Start testing LeafQueue a = (LeafQueue)queues.get(A); @@ -494,6 +496,8 @@ public class TestParentQueue { Resources.createResource(numNodes * (memoryPerNode*GB), numNodes * coresPerNode); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Start testing CSQueue a = queues.get(A); @@ -710,6 +714,8 @@ public class TestParentQueue { Resources.createResource(numNodes * (memoryPerNode*GB), numNodes * coresPerNode); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Start testing LeafQueue a = (LeafQueue)queues.get(A); @@ -790,6 +796,8 @@ public class TestParentQueue { Resources.createResource(numNodes * (memoryPerNode*GB), numNodes * coresPerNode); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Start testing LeafQueue b3 = (LeafQueue)queues.get(B3); http://git-wip-us.apache.org/repos/asf/hadoop/blob/6bf4a43e/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestReservations.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestReservations.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestReservations.java index 32f022f..0855720 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestReservations.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestReservations.java @@ -267,6 +267,8 @@ public class TestReservations { final int numNodes = 3; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); @@ -454,6 +456,8 @@ public class TestReservations { final int numNodes = 3; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); @@ -600,6 +604,8 @@ public class TestReservations { final int numNodes = 3; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); @@ -782,6 +788,8 @@ public class TestReservations { final int numNodes = 2; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); @@ -896,6 +904,10 @@ public class TestReservations { String host_1 = "host_1"; FiCaSchedulerNode node_1 = TestUtils.getMockNode(host_1, DEFAULT_RACK, 0, 8 * GB); + + Resource clusterResource = Resources.createResource(2 * 8 * GB); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests @@ -1068,6 +1080,8 @@ public class TestReservations { final int numNodes = 2; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); @@ -1256,6 +1270,8 @@ public class TestReservations { final int numNodes = 2; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); @@ -1418,6 +1434,9 @@ public class TestReservations { final int numNodes = 3; Resource clusterResource = Resources.createResource(numNodes * (8 * GB)); when(csContext.getNumClusterNodes()).thenReturn(numNodes); + root.updateClusterResource(clusterResource, + new ResourceLimits(clusterResource)); + // Setup resource-requests Priority priorityAM = TestUtils.createMockPriority(1); --------------------------------------------------------------------- To unsubscribe, e-mail: common-commits-unsubscr...@hadoop.apache.org For additional commands, e-mail: common-commits-h...@hadoop.apache.org
