@Override public Resource getUsedResources() { return queueUsage.getUsed(); }
public void setPending(Resource res) { setPending(NL, res); }
public void setUsed(Resource res) { setUsed(NL, res); }
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()); } }
ResourceUsage ru = new ResourceUsage(); ru.setPending(pending[i]); ru.setUsed(used[i]); ru.setReserved(reserved[i]); when(lq.getQueueResourceUsage()).thenReturn(ru);
public ResourcesInfo(ResourceUsage resourceUsage, boolean considerAMUsage) { if (resourceUsage == null) { return; } for (String partitionName : resourceUsage.getNodePartitionsSet()) { resourceUsagesByPartition.add(new PartitionResourcesInfo(partitionName, new ResourceInfo(resourceUsage.getUsed(partitionName)), new ResourceInfo(resourceUsage.getReserved(partitionName)), new ResourceInfo(resourceUsage.getPending(partitionName)), considerAMUsage ? new ResourceInfo(resourceUsage .getAMUsed(partitionName)) : null, considerAMUsage ? new ResourceInfo(resourceUsage .getAMLimit(partitionName)) : null, considerAMUsage ? new ResourceInfo(resourceUsage .getUserAMLimit(partitionName)) : null)); } }
usage = new ResourceUsage(); userResourceUsage.put(app.getUser(), usage); usage.incAMUsed(app.getAMResource(label)); usage.incUsed(app.getAppAttemptResourceUsage().getUsed(label)); id++;
schedulerApp1.getAppAttemptResourceUsage().getUsed().getMemorySize()); Assert.assertEquals(3 * GB, schedulerApp1.getAppAttemptResourceUsage().getReserved() .getMemorySize()); Assert.assertEquals(3 * GB, schedulerApp1.getAppAttemptResourceUsage().getPending() .getMemorySize()); cs.getApplicationAttempt(am2.getApplicationAttemptId()); Assert.assertEquals(4 * GB, schedulerApp2.getAppAttemptResourceUsage().getUsed().getMemorySize()); Assert.assertEquals(0 * GB, schedulerApp2.getAppAttemptResourceUsage().getReserved() .getMemorySize()); Assert.assertEquals(5 * 4 * GB, schedulerApp2.getAppAttemptResourceUsage().getPending() .getMemorySize());
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); } }
ResourceUsage ru = new ResourceUsage(); ru.setPending(pending[i]); ru.setUsed(used[i]); when(lq.getQueueResourceUsage()).thenReturn(ru);
Deque<ParentQueue> pqs = new LinkedList<ParentQueue>(); ParentQueue root = mockParentQueue(null, queues[0], pqs); ResourceUsage resUsage = new ResourceUsage(); resUsage.setUsed(used[0]); resUsage.setReserved(reserved[0]); when(root.getQueueName()).thenReturn(CapacitySchedulerConfiguration.ROOT); when(root.getAbsoluteUsedCapacity()).thenReturn( if (queues[i] > 0) { q = mockParentQueue(p, queues[i], pqs); ResourceUsage resUsagePerQueue = new ResourceUsage(); resUsagePerQueue.setUsed(used[i]); resUsagePerQueue.setReserved(reserved[i]); when(q.getQueueResourceUsage()).thenReturn(resUsagePerQueue); } else {
public Resource getAMUsed() { return getAMUsed(NL); }
doReturn("test").when(queue).getQueueName(); AppSchedulingInfo appSchedulingInfo = new AppSchedulingInfo(appAttemptId, "test", queue, null, 0, new ResourceUsage(), new HashMap<String, String>(), null);
ResourceUsage ru = Mockito.spy(new ResourceUsage()); ru.setUsed(label, used); when(ru.getCachedUsed(anyString())).thenReturn(used); when(app.getAppAttemptResourceUsage()).thenReturn(ru); when(app.getSchedulingResourceUsage()).thenReturn(ru);
public Resource getPending() { return getPending(NL); }
public void incUsed(Resource res) { incUsed(NL, res); }
public void incPending(Resource res) { incPending(NL, res); }
Deque<ParentQueue> pqs = new LinkedList<ParentQueue>(); ParentQueue root = mockParentQueue(null, queues[0], pqs); ResourceUsage resUsage = new ResourceUsage(); resUsage.setUsed(used[0]); when(root.getQueueName()).thenReturn("/"); when(root.getAbsoluteUsedCapacity()).thenReturn( if (queues[i] > 0) { q = mockParentQueue(p, queues[i], pqs); ResourceUsage resUsagePerQueue = new ResourceUsage(); resUsagePerQueue.setUsed(used[i]); when(q.getQueueResourceUsage()).thenReturn(resUsagePerQueue); } else {
private void unreserveInternal( SchedulerRequestKey schedulerKey, FSSchedulerNode node) { try { writeLock.lock(); Map<NodeId, RMContainer> reservedContainers = this.reservedContainers.get( schedulerKey); RMContainer reservedContainer = reservedContainers.remove( node.getNodeID()); if (reservedContainers.isEmpty()) { this.reservedContainers.remove(schedulerKey); } // Reset the re-reservation count resetReReservations(schedulerKey); Resource resource = reservedContainer.getContainer().getResource(); this.attemptResourceUsage.decReserved(resource); LOG.info( "Application " + getApplicationId() + " unreserved " + " on node " + node + ", currently has " + reservedContainers.size() + " at priority " + schedulerKey.getPriority() + "; currentReservation " + this.attemptResourceUsage .getReserved()); } finally { writeLock.unlock(); } }