YARN-8427. Don't start opportunistic containers at container scheduler/finish event with over-allocation. Contributed by Haibo Chen.
Project: http://git-wip-us.apache.org/repos/asf/hadoop/repo Commit: http://git-wip-us.apache.org/repos/asf/hadoop/commit/23ad2fbd Tree: http://git-wip-us.apache.org/repos/asf/hadoop/tree/23ad2fbd Diff: http://git-wip-us.apache.org/repos/asf/hadoop/diff/23ad2fbd Branch: refs/heads/YARN-1011 Commit: 23ad2fbd5b151fa0b19b7f224348560b8d29ac83 Parents: 3ff8d3f Author: Miklos Szegedi <[email protected]> Authored: Fri Jun 22 10:25:31 2018 -0700 Committer: Haibo Chen <[email protected]> Committed: Fri Sep 21 17:42:51 2018 -0700 ---------------------------------------------------------------------- .../containermanager/ContainerManagerImpl.java | 6 +- .../monitor/ContainersMonitorImpl.java | 2 +- .../AllocationBasedResourceTracker.java | 8 +- .../scheduler/ContainerScheduler.java | 38 +++--- .../scheduler/ResourceUtilizationTracker.java | 6 + .../UtilizationBasedResourceTracker.java | 2 +- ...estContainerSchedulerWithOverAllocation.java | 126 +++++++++++++++++-- 7 files changed, 155 insertions(+), 33 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/ContainerManagerImpl.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/ContainerManagerImpl.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/ContainerManagerImpl.java index a08e227..0850f74 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/ContainerManagerImpl.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/ContainerManagerImpl.java @@ -236,7 +236,7 @@ public class ContainerManagerImpl extends CompositeService implements this.dirsHandler = dirsHandler; // ContainerManager level dispatcher. - dispatcher = new AsyncDispatcher("NM ContainerManager dispatcher"); + dispatcher = createDispatcher(); this.deletionService = deletionContext; this.metrics = metrics; @@ -295,6 +295,10 @@ public class ContainerManagerImpl extends CompositeService implements this.writeLock = lock.writeLock(); } + protected AsyncDispatcher createDispatcher() { + return new AsyncDispatcher("NM ContainerManager dispatcher"); + } + @Override public void serviceInit(Configuration conf) throws Exception { http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/monitor/ContainersMonitorImpl.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/monitor/ContainersMonitorImpl.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/monitor/ContainersMonitorImpl.java index a045d78..8f72b56 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/monitor/ContainersMonitorImpl.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/monitor/ContainersMonitorImpl.java @@ -271,7 +271,7 @@ public class ContainersMonitorImpl extends AbstractService implements /** * Check all prerequisites for NM over-allocation. */ - private void checkOverAllocationPrerequisites() throws YarnException { + protected void checkOverAllocationPrerequisites() throws YarnException { // LinuxContainerExecutor is required to enable overallocation if (!(containerExecutor instanceof LinuxContainerExecutor)) { throw new YarnException(LinuxContainerExecutor.class.getName() + http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/AllocationBasedResourceTracker.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/AllocationBasedResourceTracker.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/AllocationBasedResourceTracker.java index 86b3698..a3e19eb 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/AllocationBasedResourceTracker.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/AllocationBasedResourceTracker.java @@ -56,11 +56,8 @@ public class AllocationBasedResourceTracker return this.containersAllocation; } - /** - * Get the amount of resources that have not been allocated to containers. - * @return Resource resources that have not been allocated to containers. - */ - protected Resource getUnallocatedResources() { + @Override + public Resource getUnallocatedResources() { // unallocated resources = node capacity - containers allocation // = -(container allocation - node capacity) ResourceUtilization allocationClone = @@ -80,7 +77,6 @@ public class AllocationBasedResourceTracker return unallocated; } - @Override public Resource getAvailableResources() { return getUnallocatedResources(); http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ContainerScheduler.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ContainerScheduler.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ContainerScheduler.java index 0bebe44..0d7de67 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ContainerScheduler.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ContainerScheduler.java @@ -218,7 +218,9 @@ public class ContainerScheduler extends AbstractService implements startPendingContainers(false); break; case SCHEDULE_CONTAINERS: - startPendingContainers(true); + // try to launch OPPORTUNISTIC containers allowing over-allocation if the + // node utilization is low. + startOpportunisticContainers(utilizationTracker.getAvailableResources()); break; default: LOG.error("Unknown event arrived at ContainerScheduler: " @@ -410,11 +412,7 @@ public class ContainerScheduler extends AbstractService implements this.metrics.completeOpportunisticContainer(container.getResource()); } - // In case of over-allocation being turned on, we may need to reclaim - // more resources since the opportunistic containers that have been - // killed or paused may have not released as much resource as we need. - boolean reclaimOpportunisticResources = context.isOverAllocationEnabled(); - startPendingContainers(reclaimOpportunisticResources); + startPendingContainers(false); } } @@ -434,22 +432,32 @@ public class ContainerScheduler extends AbstractService implements return; } + boolean guaranteedContainersLaunched = startGuaranteedContainers( + reclaimOpportunisticResources); + + if (guaranteedContainersLaunched) { + // if all GUARANTEED containers are launched, try to launch OPPORTUNISTIC + // containers with unallocated resources only. + startOpportunisticContainers( + utilizationTracker.getUnallocatedResources()); + } + } + + private boolean startGuaranteedContainers( + boolean reclaimOpportunisticResources) { Resource available = utilizationTracker.getAvailableResources(); // Start guaranteed containers that are queued, if resources available. boolean allGuaranteedContainersLaunched = startGuaranteedContainers(available); - // Start opportunistic containers, if resources available, which is true - // if all guaranteed containers in queue have been launched. - if (allGuaranteedContainersLaunched) { - startOpportunisticContainers(available); - } else { + + if (!allGuaranteedContainersLaunched && reclaimOpportunisticResources) { // If not all guaranteed containers in queue are launched, we may need // to reclaim resources from opportunistic containers that are running. - if (reclaimOpportunisticResources) { - reclaimOpportunisticContainerResources(); - } + reclaimOpportunisticContainerResources(); } + + return allGuaranteedContainersLaunched; } /** @@ -693,8 +701,6 @@ public class ContainerScheduler extends AbstractService implements * * If the node is over-allocating itself, this may cause not enough * OPPORTUNISTIC containers being killed/paused in cases where the running - * OPPORTUNISTIC containers are not consuming fully their resource requests. - * We'd check again upon container completion events to see if more running * OPPORTUNISTIC containers need to be killed/paused. * * @return the amount of resource needed to be reclaimed for this container http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ResourceUtilizationTracker.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ResourceUtilizationTracker.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ResourceUtilizationTracker.java index 98d99c6..7a7c78e 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ResourceUtilizationTracker.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/ResourceUtilizationTracker.java @@ -45,6 +45,12 @@ public interface ResourceUtilizationTracker { Resource getAvailableResources(); /** + * Get the amount of resources left un-allocated. + * @return Resource unallocated resources + */ + Resource getUnallocatedResources(); + + /** * Add Container's resources to Node Utilization upon container launch. * @param container Container. */ http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/UtilizationBasedResourceTracker.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/UtilizationBasedResourceTracker.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/UtilizationBasedResourceTracker.java index 6f9bc82..f976700 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/UtilizationBasedResourceTracker.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/main/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/UtilizationBasedResourceTracker.java @@ -61,7 +61,7 @@ public class UtilizationBasedResourceTracker @Override public Resource getAvailableResources() { - Resource resourceBasedOnAllocation = getUnallocatedResources(); + Resource resourceBasedOnAllocation = super.getUnallocatedResources(); Resource resourceBasedOnUtilization = getResourcesAvailableBasedOnUtilization(); if (LOG.isDebugEnabled()) { http://git-wip-us.apache.org/repos/asf/hadoop/blob/23ad2fbd/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/test/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/TestContainerSchedulerWithOverAllocation.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/test/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/TestContainerSchedulerWithOverAllocation.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/test/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/TestContainerSchedulerWithOverAllocation.java index 384b116..183d868 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/test/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/TestContainerSchedulerWithOverAllocation.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-nodemanager/src/test/java/org/apache/hadoop/yarn/server/nodemanager/containermanager/scheduler/TestContainerSchedulerWithOverAllocation.java @@ -37,6 +37,7 @@ import org.apache.hadoop.yarn.api.records.ResourceUtilization; import org.apache.hadoop.yarn.api.records.Token; import org.apache.hadoop.yarn.conf.YarnConfiguration; import org.apache.hadoop.yarn.event.AsyncDispatcher; +import org.apache.hadoop.yarn.event.DrainDispatcher; import org.apache.hadoop.yarn.exceptions.ConfigurationException; import org.apache.hadoop.yarn.exceptions.YarnException; import org.apache.hadoop.yarn.security.NMTokenIdentifier; @@ -114,6 +115,9 @@ public class TestContainerSchedulerWithOverAllocation conf.setFloat( YarnConfiguration.NM_OVERALLOCATION_MEMORY_UTILIZATION_THRESHOLD, 0.75f); + // disable the monitor thread in ContainersMonitor to allow control over + // when opportunistic containers are launched with over-allocation + conf.setBoolean(YarnConfiguration.NM_CONTAINER_MONITOR_ENABLED, false); super.setup(); } @@ -190,6 +194,27 @@ public class TestContainerSchedulerWithOverAllocation BuilderUtils.newResource(512, 1), false)) )); + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + + // this container is not expected to be started immediately because + // opportunistic containers cannot be started if the node would be + // over-allocated + BaseContainerManagerTest.waitForContainerSubState( + containerManager, createContainerId(2), ContainerSubState.SCHEDULED); + + verifyContainerStatuses(new HashMap<ContainerId, ContainerSubState>() { + { + put(createContainerId(0), ContainerSubState.RUNNING); + put(createContainerId(1), ContainerSubState.RUNNING); + put(createContainerId(2), ContainerSubState.SCHEDULED); + } + }); + + // try to start opportunistic containers out of band. + ((LongRunningContainerSimulatingContainersManager) containerManager) + .startContainersOutOfBandUponLowUtilization(); + // this container is expected to be started immediately because there // are (memory: 1024, vcore: 0.625) available based on over-allocation BaseContainerManagerTest.waitForContainerSubState( @@ -244,6 +269,16 @@ public class TestContainerSchedulerWithOverAllocation createStartContainerRequest(2, BuilderUtils.newResource(512, 1), false)) )); + + // try to start opportunistic containers out of band because they can + // not be launched at container scheduler event if the node would be + // over-allocated. + ((LongRunningContainerSimulatingContainersManager) containerManager) + .startContainersOutOfBandUponLowUtilization(); + + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + // this container will not start immediately because there is not // enough resource available at the moment either in terms of // resources unallocated or in terms of the actual utilization @@ -299,6 +334,27 @@ public class TestContainerSchedulerWithOverAllocation BuilderUtils.newResource(512, 1), false)) )); + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + + // this container is not expected to be started immediately because + // opportunistic containers cannot be started if the node would be + // over-allocated + BaseContainerManagerTest.waitForContainerSubState( + containerManager, createContainerId(2), ContainerSubState.SCHEDULED); + + verifyContainerStatuses(new HashMap<ContainerId, ContainerSubState>() { + { + put(createContainerId(0), ContainerSubState.RUNNING); + put(createContainerId(1), ContainerSubState.RUNNING); + put(createContainerId(2), ContainerSubState.SCHEDULED); + } + }); + + // try to start opportunistic containers out of band. + ((LongRunningContainerSimulatingContainersManager) containerManager) + .startContainersOutOfBandUponLowUtilization(); + // this container is expected to be started because there is resources // available because the actual utilization is very low BaseContainerManagerTest.waitForContainerSubState(containerManager, @@ -355,6 +411,9 @@ public class TestContainerSchedulerWithOverAllocation containerManager.startContainers( StartContainersRequest.newInstance(moreContainerRequests)); + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + // All OPPORTUNISTIC containers but the last one should be queued. // The last OPPORTUNISTIC container to launch should be killed. BaseContainerManagerTest.waitForContainerState( @@ -580,13 +639,27 @@ public class TestContainerSchedulerWithOverAllocation } } )); - // All three GUARANTEED containers are all expected to start - // because the containers utilization is low (0 at the point) + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + + // Two OPPORTUNISTIC containers are expected to start with the + // unallocated resources, but one will be queued because no + // over-allocation is allowed at container scheduler events. BaseContainerManagerTest.waitForContainerSubState(containerManager, createContainerId(0), ContainerSubState.RUNNING); BaseContainerManagerTest.waitForContainerSubState(containerManager, createContainerId(1), ContainerSubState.RUNNING); BaseContainerManagerTest.waitForContainerSubState(containerManager, + createContainerId(2), ContainerSubState.SCHEDULED); + + // try to start the opportunistic container out of band because it can + // not be launched at container scheduler event if the node would be + // over-allocated. + ((LongRunningContainerSimulatingContainersManager) containerManager) + .startContainersOutOfBandUponLowUtilization(); + + // now the queued opportunistic container should also start + BaseContainerManagerTest.waitForContainerSubState(containerManager, createContainerId(2), ContainerSubState.RUNNING); // the containers utilization is low @@ -625,7 +698,6 @@ public class TestContainerSchedulerWithOverAllocation * and fourth OPPORTUNISTIC container (which releases no resources) and * then the second OPPORTUNISTIC container. */ - @Test public void testKillOppContainersConservativelyWithOverallocationHighUtilization() throws Exception { @@ -730,7 +802,7 @@ public class TestContainerSchedulerWithOverAllocation BaseContainerManagerTest.waitForContainerSubState(containerManager, createContainerId(2), ContainerSubState.RUNNING); - // the contianers utilization is at the overallocation threshold + // the container utilization is at the overallocation threshold setContainerResourceUtilization( ResourceUtilization.newInstance(1536, 0, 1.0f/2)); @@ -740,7 +812,7 @@ public class TestContainerSchedulerWithOverAllocation add(createStartContainerRequest(3, BuilderUtils.newResource(512, 1), false)); add(createStartContainerRequest(4, - BuilderUtils.newResource(512, 1), false)); + BuilderUtils.newResource(800, 1), false)); } } )); @@ -759,12 +831,35 @@ public class TestContainerSchedulerWithOverAllocation BaseContainerManagerTest.waitForContainerSubState(containerManager, createContainerId(2), ContainerSubState.DONE); - // the two OPPORTUNISTIC containers are expected to start together + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + + // only one OPPORTUNISTIC container is start because no over-allocation + // is allowed to start OPPORTUNISTIC containers at container finish event. BaseContainerManagerTest.waitForContainerSubState(containerManager, createContainerId(3), ContainerSubState.RUNNING); BaseContainerManagerTest.waitForContainerSubState(containerManager, - createContainerId(4), ContainerSubState.RUNNING); + createContainerId(4), ContainerSubState.SCHEDULED); + + verifyContainerStatuses(new HashMap<ContainerId, ContainerSubState>() { + { + put(createContainerId(0), ContainerSubState.RUNNING); + put(createContainerId(1), ContainerSubState.RUNNING); + put(createContainerId(2), ContainerSubState.DONE); + put(createContainerId(3), ContainerSubState.RUNNING); + put(createContainerId(4), ContainerSubState.SCHEDULED); + } + }); + // now try to start the OPPORTUNISTIC container that was queued because + // we don't start OPPORTUNISTIC containers at container finish event if + // the node would be over-allocated + ((LongRunningContainerSimulatingContainersManager) containerManager) + .startContainersOutOfBandUponLowUtilization(); + ((LongRunningContainerSimulatingContainersManager) containerManager) + .drainAsyncEvents(); + BaseContainerManagerTest.waitForContainerSubState(containerManager, + createContainerId(4), ContainerSubState.RUNNING); verifyContainerStatuses(new HashMap<ContainerId, ContainerSubState>() { { put(createContainerId(0), ContainerSubState.RUNNING); @@ -817,7 +912,7 @@ public class TestContainerSchedulerWithOverAllocation setContainerResourceUtilization( ResourceUtilization.newInstance(1536, 0, 1.0f/2)); - // try to start containers out of band. + // try to start opportunistic containers out of band. ((LongRunningContainerSimulatingContainersManager)containerManager) .startContainersOutOfBandUponLowUtilization(); @@ -937,6 +1032,11 @@ public class TestContainerSchedulerWithOverAllocation return ugi; } + @Override + protected AsyncDispatcher createDispatcher() { + return new DrainDispatcher(); + } + /** * Create a container launcher that signals container processes * with a dummy pid. The container processes are simulated in @@ -977,6 +1077,10 @@ public class TestContainerSchedulerWithOverAllocation ((ContainerMonitorForOverallocationTest) getContainersMonitor()) .attemptToStartContainersUponLowUtilization(); } + + public void drainAsyncEvents() { + ((DrainDispatcher) dispatcher).await(); + } } /** @@ -1113,6 +1217,12 @@ public class TestContainerSchedulerWithOverAllocation containerResourceUsage, System.currentTimeMillis()); } + @Override + protected void checkOverAllocationPrerequisites() { + // do not check + } + + public void setContainerResourceUsage( ResourceUtilization containerResourceUsage) { this.containerResourceUsage = containerResourceUsage; --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
