import org.apache.hadoop.yarn.server.utils.Lock.NoLock; //导入依赖的package包/类
@Lock(NoLock.class)
public int getNodeLocalityDelay() {
  return nodeLocalityDelay;
}
 

import org.apache.hadoop.yarn.server.utils.Lock.NoLock; //导入依赖的package包/类
@Lock(NoLock.class)
public boolean getRackLocalityFullReset() {
  return rackLocalityFullReset;
}
 

import org.apache.hadoop.yarn.server.utils.Lock.NoLock; //导入依赖的package包/类
@Lock(NoLock.class)
private Resource computeUserLimit(FiCaSchedulerApp application, 
    Resource clusterResource, Resource required) {
  // What is our current capacity? 
  // * It is equal to the max(required, queue-capacity) if
  //   we're running below capacity. The 'max' ensures that jobs in queues
  //   with miniscule capacity (< 1 slot) make progress
  // * If we're running over capacity, then its
  //   (usedResources + required) (which extra resources we are allocating)

  // Allow progress for queues with miniscule capacity
  final Resource queueCapacity =
      Resources.max(
          resourceCalculator, clusterResource, 
          Resources.multiplyAndNormalizeUp(
              resourceCalculator, 
              clusterResource, 
              absoluteCapacity, 
              minimumAllocation), 
          required);

  Resource currentCapacity =
      Resources.lessThan(resourceCalculator, clusterResource, 
          usedResources, queueCapacity) ?
          queueCapacity : Resources.add(usedResources, required);
  
  // Never allow a single user to take more than the 
  // queue's configured capacity * user-limit-factor.
  // Also, the queue's configured capacity should be higher than 
  // queue-hard-limit * ulMin
  
  final int activeUsers = activeUsersManager.getNumActiveUsers();  
  		
  Resource limit =
      Resources.roundUp(
          resourceCalculator, 
          Resources.min(
              resourceCalculator, clusterResource,   
              Resources.max(
                  resourceCalculator, clusterResource, 
                  Resources.divideAndCeil(
                      resourceCalculator, currentCapacity, activeUsers),
                  Resources.divideAndCeil(
                      resourceCalculator, 
                      Resources.multiplyAndRoundDown(
                          currentCapacity, userLimit), 
                      100)
                  ), 
              Resources.multiplyAndRoundDown(queueCapacity, userLimitFactor)
              ), 
          minimumAllocation);

  if (LOG.isDebugEnabled()) {
    String userName = application.getUser();
    LOG.debug("User limit computation for " + userName + 
        " in queue " + getQueueName() +
        " userLimit=" + userLimit +
        " userLimitFactor=" + userLimitFactor +
        " required: " + required + 
        " consumed: " + getUser(userName).getConsumedResources() + 
        " limit: " + limit +
        " queueCapacity: " + queueCapacity + 
        " qconsumed: " + usedResources +
        " currentCapacity: " + currentCapacity +
        " activeUsers: " + activeUsers +
        " clusterCapacity: " + clusterResource
    );
  }

  return limit;
}