Method Detail

• setClasses

  public void setClasses(Map<ResourceClass,ResourceClass> prclasses)

  Specified by:

  setClasses in interface IScheduler

• setNodePool

  public void setNodePool(org.apache.uima.ducc.rm.scheduler.NodePool np)

  Specified by:

  setNodePool in interface IScheduler

• setEvictionPolicy

  public void setEvictionPolicy(SchedConstants.EvictionPolicy ep)

  Specified by:

  setEvictionPolicy in interface IScheduler

• apportion_qshares

  protected void apportion_qshares(List<org.apache.uima.ducc.rm.scheduler.IEntity> entities,
                       int[] vshares,
                       String descr)

• countClassShares

  protected void countClassShares(org.apache.uima.ducc.rm.scheduler.NodePool np,
                      List<ResourceClass> rcs)

  Count out shares for only the jobs in the ResouceClasses here, and only from the given nodepool.

• countUserShares

  protected boolean countUserShares(ResourceClass rc)

  Count out shares for only the jobs in the ResouceClasses here, and only from the given nodepool.

• traverseNodepoolsForCounts

  protected List<ResourceClass> traverseNodepoolsForCounts(org.apache.uima.ducc.rm.scheduler.NodePool np,
                                               List<ResourceClass> eligible)

  Do a depth-first traversal of the nodepool calculating counts for all the jobs in the nodepool and its children. Starting at each leaf NP, gather all the classes that have jobs in the NP, and if there are any, get class counts for the classes. Pass the classes up to the caller who can do a more global recount if necessary. If there are no jobs over the nodepool then bypass the count for it, of course. This is a rewrite of the original which did not properly handle the recursion past 1 level (root + 1). It uses gatherRcs() as a helper to find relevent classes. jrc 2014-11-05. UIMA-4605 Note that this is tricky - please make sure you understand all the logic in countClassShares before changing anything.

  Parameters:

  np -

  eligible -

  Returns:

  List of classes with potential counts.

• updateNodepools

  protected void updateNodepools(org.apache.uima.ducc.rm.scheduler.NodePool np,
                     ArrayList<ResourceClass> rcs)

• jobInClass

  protected boolean jobInClass(ArrayList<ResourceClass> rcs,
                   IRmJob j)

  Is the job submitted to one of these classes?

• expandNeedyJobs

  protected void expandNeedyJobs(org.apache.uima.ducc.rm.scheduler.NodePool np,
                     ArrayList<ResourceClass> rcs)

  Expand jobs from the needy list ahead of other jobs, because we likely stole the shares from older jobs which would otherwise get priority.

• traverseNodepoolsForExpansion

  protected void traverseNodepoolsForExpansion(org.apache.uima.ducc.rm.scheduler.NodePool np,
                                   ArrayList<ResourceClass> rcs)

• whatOfFairShare

  protected void whatOfFairShare(ArrayList<ResourceClass> rcs)

  Counts are established. We strictly honor them inside each job and evict where the count is less than the currently allocated shares, and add where it is greater.

• whatOfFixedShare

  protected void whatOfFixedShare(ArrayList<ResourceClass> rcs)

  If there are free shares of the right order just assign them. Otherwise the counts will cause evictions in lower-priority code so we just wait.

• accountForNonPreemptable

  protected void accountForNonPreemptable()

  Remove non-preemptable resources from the counts.

• accountForFairShare

  protected void accountForFairShare()

  Remove active shares from the nodepool counts, leaving us with just the free shares in the tables.

• findHowMuch

  protected void findHowMuch(ArrayList<ResourceClass> rcs)

  The second stage - work up all counts globally

• doEvictions

  protected void doEvictions(org.apache.uima.ducc.rm.scheduler.NodePool nodepool)

  Collect all the fair-share classes and pass them to the nodepools for eviction This interacts recursively with NodePool.doEvictions*. In NodepoolScheduler we recurse doing depth-first traversal to have every nodepool do evictions for jobs that are submitted to that pool. The NodePool then recurses again in depth-first mode to evict shares that have spilled into lower-level pools. We have a double-recursion: 1. Evict shares for jobs that originate in each node pool 2. Evict shares that have spilled into lower-level pools.

• findWhatOf

  protected void findWhatOf(ArrayList<ResourceClass> rcs)

  The third stage - work up all counts globally

• schedule

  public void schedule(SchedulingUpdate upd)

  IScheduler entry point for the fairShare calculation. This implements the easy three step process described at the top of the file.

  Specified by:

  schedule in interface IScheduler