public void incUsed(Resource res) { incUsed(NL, res); }
public void incUsed(Resource res) { incUsed(NL, res); }
public void incUsed(Resource res) { incUsed(NL, res); }
void allocateResource(Resource clusterResource, Resource resource, String nodePartition) { try { writeLock.lock(); queueUsage.incUsed(nodePartition, resource); ++numContainers; CSQueueUtils.updateQueueStatistics(resourceCalculator, clusterResource, this, labelManager, nodePartition); } finally { writeLock.unlock(); } }
synchronized void allocateResource(Resource clusterResource, Resource resource, Set<String> nodeLabels) { // Update usedResources by labels if (nodeLabels == null || nodeLabels.isEmpty()) { queueUsage.incUsed(resource); } else { Set<String> anls = (accessibleLabels.contains(RMNodeLabelsManager.ANY)) ? labelManager.getClusterNodeLabels() : accessibleLabels; for (String label : Sets.intersection(anls, nodeLabels)) { queueUsage.incUsed(label, resource); } } ++numContainers; CSQueueUtils.updateQueueStatistics(resourceCalculator, this, getParent(), clusterResource, minimumAllocation); }
synchronized void allocateResource(Resource clusterResource, Resource resource, Set<String> nodeLabels) { // Update usedResources by labels if (nodeLabels == null || nodeLabels.isEmpty()) { queueUsage.incUsed(resource); } else { Set<String> anls = (accessibleLabels.contains(RMNodeLabelsManager.ANY)) ? labelManager.getClusterNodeLabels() : accessibleLabels; for (String label : Sets.intersection(anls, nodeLabels)) { queueUsage.incUsed(label, resource); } } ++numContainers; CSQueueUtils.updateQueueStatistics(resourceCalculator, this, getParent(), clusterResource, minimumAllocation); }
private void updateResourceUsagePerUser(User user, Resource resource, String nodePartition, boolean isAllocate) { ResourceUsage totalResourceUsageForUsers = getTotalResourceUsagePerUser( user.userName); if (isAllocate) { user.getResourceUsage().incUsed(nodePartition, resource); totalResourceUsageForUsers.incUsed(nodePartition, resource); } else { user.getResourceUsage().decUsed(nodePartition, resource); totalResourceUsageForUsers.decUsed(nodePartition, resource); } if (LOG.isDebugEnabled()) { LOG.debug( "User resource is updated." + "Total Resource usage for active users=" + totalResUsageForActiveUsers.getAllUsed() + "." + "Total Resource usage for non-active users=" + totalResUsageForNonActiveUsers.getAllUsed()); } }
public void addRMContainer( ContainerId id, RMContainer rmContainer) { try { writeLock.lock(); if (!getApplicationAttemptId().equals( rmContainer.getApplicationAttemptId()) && !liveContainers.containsKey(id)) { LOG.info("recovered container " + id + " from previous attempt " + rmContainer.getApplicationAttemptId()); recoveredPreviousAttemptContainers.add(rmContainer.getContainer()); } liveContainers.put(id, rmContainer); if (rmContainer.getExecutionType() == ExecutionType.OPPORTUNISTIC) { this.attemptOpportunisticResourceUsage.incUsed( rmContainer.getAllocatedResource()); } if (rmContainer.isRemotelyAllocated()) { this.attemptResourceUsageAllocatedRemotely.incUsed( rmContainer.getAllocatedResource()); } } finally { writeLock.unlock(); } }
@Override public void incUsedResource(String nodeLabel, Resource resourceToInc, SchedulerApplicationAttempt application) { if (nodeLabel == null) { nodeLabel = RMNodeLabelsManager.NO_LABEL; } // ResourceUsage has its own lock, no addition lock needs here. queueUsage.incUsed(nodeLabel, resourceToInc); CSQueueUtils.updateUsedCapacity(resourceCalculator, labelManager.getResourceByLabel(nodeLabel, Resources.none()), nodeLabel, this); if (null != parent) { parent.incUsedResource(nodeLabel, resourceToInc, null); } }
totalResUsageForNonActiveUsers.decUsed(partition, resourceUsage.getUsed(partition)); totalResUsageForActiveUsers.incUsed(partition, resourceUsage.getUsed(partition));
totalResUsageForActiveUsers.decUsed(partition, resourceUsage.getUsed(partition)); totalResUsageForNonActiveUsers.incUsed(partition, resourceUsage.getUsed(partition));
public void recoverContainer(SchedulerNode node, RMContainer rmContainer) { try { writeLock.lock(); // recover app scheduling info appSchedulingInfo.recoverContainer(rmContainer, node.getPartition()); if (rmContainer.getState().equals(RMContainerState.COMPLETED)) { return; } LOG.info("SchedulerAttempt " + getApplicationAttemptId() + " is recovering container " + rmContainer.getContainerId()); addRMContainer(rmContainer.getContainerId(), rmContainer); if (rmContainer.getExecutionType() == ExecutionType.GUARANTEED) { attemptResourceUsage.incUsed(node.getPartition(), rmContainer.getContainer().getResource()); } // resourceLimit: updated when LeafQueue#recoverContainer#allocateResource // is called. // newlyAllocatedContainers.add(rmContainer); // schedulingOpportunities // lastScheduledContainer } finally { writeLock.unlock(); } }
@Test public void testAppPercentagesOnswitch() throws Exception { FifoScheduler scheduler = mock(FifoScheduler.class); when(scheduler.getClusterResource()).thenReturn(Resource.newInstance(0, 0)); when(scheduler.getResourceCalculator()) .thenReturn(new DefaultResourceCalculator()); ApplicationAttemptId appAttId = createAppAttemptId(0, 0); RMContext rmContext = mock(RMContext.class); when(rmContext.getEpoch()).thenReturn(3L); when(rmContext.getScheduler()).thenReturn(scheduler); final String user = "user1"; Queue queue = createQueue("test", null); SchedulerApplicationAttempt app = new SchedulerApplicationAttempt(appAttId, user, queue, queue.getAbstractUsersManager(), rmContext); // Resource request Resource requestedResource = Resource.newInstance(1536, 2); app.attemptResourceUsage.incUsed(requestedResource); assertEquals(0.0f, app.getResourceUsageReport().getQueueUsagePercentage(), 0.0f); assertEquals(0.0f, app.getResourceUsageReport().getClusterUsagePercentage(), 0.0f); }
type, node, schedulerKey, container); attemptResourceUsage.incUsed(node.getPartition(), container.getResource());
public void nodePartitionUpdated(RMContainer rmContainer, String oldPartition, String newPartition) { Resource containerResource = rmContainer.getAllocatedResource(); this.attemptResourceUsage.decUsed(oldPartition, containerResource); this.attemptResourceUsage.incUsed(newPartition, containerResource); getCSLeafQueue().decUsedResource(oldPartition, containerResource, this); getCSLeafQueue().incUsedResource(newPartition, containerResource, this); // Update new partition name if container is AM and also update AM resource if (rmContainer.isAMContainer()) { setAppAMNodePartitionName(newPartition); this.attemptResourceUsage.decAMUsed(oldPartition, containerResource); this.attemptResourceUsage.incAMUsed(newPartition, containerResource); getCSLeafQueue().decAMUsedResource(oldPartition, containerResource, this); getCSLeafQueue().incAMUsedResource(newPartition, containerResource, this); } }
app.attemptResourceUsage.incUsed(requestedResource); app = new SchedulerApplicationAttempt(appAttId, user, queue, queue.getAbstractUsersManager(), rmContext); app.attemptResourceUsage.incUsed(requestedResource); assertEquals(30.0f, app.getResourceUsageReport().getQueueUsagePercentage(), 0.01f); app.getResourceUsageReport().getClusterUsagePercentage(), 0.01f); app.attemptResourceUsage.incUsed(requestedResource); app.attemptResourceUsage.incUsed(requestedResource); app.attemptResourceUsage.incUsed(requestedResource); app.attemptResourceUsage.incUsed(requestedResource);
this.attemptResourceUsage.incUsed(container.getResource()); getQueue().incUsedResource(container.getResource());
app.getAppAttemptResourceUsage().incUsed(requestedResource); app = new FiCaSchedulerApp(appAttId, user, queue, queue.getAbstractUsersManager(), rmContext); app.getAppAttemptResourceUsage().incUsed(requestedResource); app = new FiCaSchedulerApp(appAttId, user, qChild, qChild.getAbstractUsersManager(), rmContext); app.getAppAttemptResourceUsage().incUsed(requestedResource);