private static void deductPreemptableResourcePerApp( CapacitySchedulerPreemptionContext context, Resource totalPartitionResource, Collection<TempAppPerPartition> tas, Resource res) { for (TempAppPerPartition ta : tas) { ta.deductActuallyToBePreempted(context.getResourceCalculator(), totalPartitionResource, res); } }
public long getMaximumKillWaitTimeMs() { if (maximumKillWaitTime > 0) { return maximumKillWaitTime; } return preemptionContext.getDefaultMaximumKillWaitTimeout(); }
IntraQueueCandidatesSelector( CapacitySchedulerPreemptionContext preemptionContext) { super(preemptionContext); fifoPreemptionComputePlugin = new FifoIntraQueuePreemptionPlugin(rc, preemptionContext); context = preemptionContext; }
public void computeIdealAllocation(Resource clusterResource, Resource totalPreemptionAllowed) { for (String partition : context.getAllPartitions()) { TempQueuePerPartition tRoot = context.getQueueByPartition( CapacitySchedulerConfiguration.ROOT, partition); updatePreemptableExtras(tRoot); // compute the ideal distribution of resources among queues // updates cloned queues state accordingly tRoot.initializeRootIdealWithGuarangeed(); recursivelyComputeIdealAssignment(tRoot, totalPreemptionAllowed); } // based on ideal allocation select containers to be preempted from each // calculate resource-to-obtain by partition for each leaf queues calculateResToObtainByPartitionForLeafQueues(context.getLeafQueueNames(), clusterResource); } }
ParentQueue buildMockRootQueue(Random r, int[]... queueData) { Resource[] abs = generateResourceList(queueData[0]); Resource[] used = generateResourceList(queueData[2]); Resource[] pending = generateResourceList(queueData[3]); Resource[] reserved = generateResourceList(queueData[4]); Resource[] gran = generateResourceList(queueData[6]); int[] maxCap = queueData[1]; int[] apps = queueData[5]; int[] queues = queueData[7]; return mockNested(abs, maxCap, used, pending, reserved, apps, gran, queues); }
ParentQueue buildMockRootQueue(Random r, String[][] resData, int[]... queueData) { Resource[] abs = parseResourceDetails(resData[0]); Resource[] used = parseResourceDetails(resData[1]); Resource[] pending = parseResourceDetails(resData[2]); Resource[] reserved = parseResourceDetails(resData[3]); Resource[] gran = parseResourceDetails(resData[4]); int[] maxCap = queueData[0]; int[] apps = queueData[1]; int[] queues = queueData[2]; return mockNested(abs, maxCap, used, pending, reserved, apps, gran, queues); }
@Before public void setup() { super.setup(); policy = new ProportionalCapacityPreemptionPolicy(rmContext, cs, mClock); }
public ProportionalCapacityPreemptionPolicy(Configuration config, RMContext context, CapacityScheduler scheduler, Clock clock) { init(config, context, scheduler); this.clock = clock; }
@Override public int compare(TempQueue tq1, TempQueue tq2) { if (getIdealPctOfGuaranteed(tq1) < getIdealPctOfGuaranteed(tq2)) { return -1; } if (getIdealPctOfGuaranteed(tq1) > getIdealPctOfGuaranteed(tq2)) { return 1; } return 0; }
private void updatePreemptableExtras(TempQueuePerPartition cur) { if (cur.children == null || cur.children.isEmpty()) { cur.updatePreemptableExtras(rc); } else { for (TempQueuePerPartition child : cur.children) { updatePreemptableExtras(child); } cur.updatePreemptableExtras(rc); } }
ProportionalCapacityPreemptionPolicy buildPolicy(int[][] qData, String[][] resData) { return buildPolicy(qData, resData, false); }
ReservedContainerCandidatesSelector( CapacitySchedulerPreemptionContext preemptionContext) { super(preemptionContext); preemptableAmountCalculator = new PreemptableResourceCalculator( preemptionContext, true, false); }
PreemptionCandidatesSelector( CapacitySchedulerPreemptionContext preemptionContext) { this.preemptionContext = preemptionContext; this.rc = preemptionContext.getResourceCalculator(); }
public void buildEnv(String labelsConfig, String nodesConfig, String queuesConfig, String appsConfig) throws IOException { buildEnv(labelsConfig, nodesConfig, queuesConfig, appsConfig, false); }
ParentQueue buildMockRootQueue(Random r, int[]... queueData) { Resource[] abs = generateResourceList(queueData[0]); Resource[] used = generateResourceList(queueData[2]); Resource[] pending = generateResourceList(queueData[3]); Resource[] reserved = generateResourceList(queueData[4]); Resource[] gran = generateResourceList(queueData[6]); int[] maxCap = queueData[1]; int[] apps = queueData[5]; int[] queues = queueData[7]; return mockNested(abs, maxCap, used, pending, reserved, apps, gran, queues); }
private ParentQueue buildMockRootQueue(Random rand2, String[][] resData, int[][] queueData) { Resource[] abs = parseResourceDetails(resData[0]); Resource[] used = parseResourceDetails(resData[1]); Resource[] pending = parseResourceDetails(resData[2]); Resource[] reserved = parseResourceDetails(resData[3]); Resource[] gran = parseResourceDetails(resData[4]); int[] maxCap = queueData[0]; int[] apps = queueData[1]; int[] queues = queueData[2]; return mockNested(abs, maxCap, used, pending, reserved, apps, gran, queues); }
@Before public void setup() { super.setup(); conf.setBoolean( CapacitySchedulerConfiguration.INTRAQUEUE_PREEMPTION_ENABLED, true); policy = new ProportionalCapacityPreemptionPolicy(rmContext, cs, mClock); }
public ProportionalCapacityPreemptionPolicy(Configuration config, RMContext context, CapacityScheduler scheduler, Clock clock) { init(config, context, scheduler); this.clock = clock; }
@Override public int compare(TempQueue tq1, TempQueue tq2) { if (getIdealPctOfGuaranteed(tq1) < getIdealPctOfGuaranteed(tq2)) { return -1; } if (getIdealPctOfGuaranteed(tq1) > getIdealPctOfGuaranteed(tq2)) { return 1; } return 0; }
FifoCandidatesSelector(CapacitySchedulerPreemptionContext preemptionContext, boolean includeReservedResource, boolean allowQueuesBalanceAfterAllQueuesSatisfied) { super(preemptionContext); this.allowQueuesBalanceAfterAllQueuesSatisfied = allowQueuesBalanceAfterAllQueuesSatisfied; preemptableAmountCalculator = new PreemptableResourceCalculator( preemptionContext, includeReservedResource, allowQueuesBalanceAfterAllQueuesSatisfied); }