ResourceClass (Apache UIMA DUCC: uima-ducc-rm 2.0.0 API)

java.lang.Object
- org.apache.uima.ducc.rm.scheduler.ResourceClass

All Implemented Interfaces:

SchedConstants
```
public class ResourceClass
extends Object
implements SchedConstants
```
This represents a priority class.

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.uima.ducc.rm.scheduler.SchedConstants
  SchedConstants.EvictionPolicy, SchedConstants.Policy

Field Summary
- Fields inherited from interface org.apache.uima.ducc.rm.scheduler.SchedConstants
  COMPONENT_NAME, DEFAULT_INIT_STABILITY_COUNT, DEFAULT_INSTANCES, DEFAULT_MAX_INSTANCES, DEFAULT_MAX_PROCESSES, DEFAULT_NODE_METRICS_RATE, DEFAULT_OR_PUBLISH_RATE, DEFAULT_PRIORITY, DEFAULT_PROCESSES, DEFAULT_RM_PUBLISHING_SLOP, DEFAULT_SCHEDULING_RATE, DEFAULT_SCHEDULING_RATIO, DEFAULT_SHARE_WEIGHT, DEFAULT_STABILITY_COUNT

Constructor Summary

Constructors
Constructor and Description

ResourceClass(org.apache.uima.ducc.common.utils.DuccProperties props, long share_quantum)

Constructors
Constructor and Description
`ResourceClass(org.apache.uima.ducc.common.utils.DuccProperties props, long share_quantum)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`allotmentExceeded(IRmJob j)` Does this job push the per-user allotment over the top? Note that we don't store current occupancy directly, we always calculate it from the jobs assigned to the class.
`boolean`	`authorized(String user)`
`int`	`calculateCap()`
`boolean`	`canUseBonus(int order)` Can I use more 1 more share of this size? This is more complex than for Users and Jobs because in addition to checking if my request is filled, we need to make sure the underlying nodepools can support the bonus.
`void`	`clearShares()`
`boolean`	`enforceMemory()`
`boolean`	`fairShareCapExceeded(IRmJob j)`
`int`	`getAllotment(IRmJob j)`
`Comparator<org.apache.uima.ducc.rm.scheduler.IEntity>`	`getApportionmentSorter()`
`static String`	`getDashes()`
`int`	`getEffectiveWeight(int order)` Return my share weight, if I have any jobs of the given order or less.
`int[]`	`getGivenByOrder()`
`static String`	`getHeader()`
`int`	`getInitializationCap()`
`String`	`getName()` public String getId() { return id; }
`org.apache.uima.ducc.rm.scheduler.NodePool`	`getNodepool()`
`SchedConstants.Policy`	`getPolicy()`
`long`	`getPredictionFudge()`
`int`	`getPriority()`
`int`	`getPureFairShare()`
`int`	`getShareWeight()`
`long`	`getTimestamp()`
`int`	`getTrueCap()`
`int[]`	`getWantedByOrder()`
`int`	`hashCode()`
`boolean`	`hasSharesGiven()`
`void`	`initWantedByOrder(ResourceClass unused)`
`boolean`	`isExpandByDoubling()`
`boolean`	`isUsePrediction()`
`void`	`setExpandByDoubling(boolean ebd)`
`void`	`setGivenByOrder(int[] gbo)`
`void`	`setInitializationCap(int c)`
`void`	`setNodepool(org.apache.uima.ducc.rm.scheduler.NodePool np)`
`void`	`setPureFairShare(int pfs)`
`void`	`setTrueCap(int cap)`
`String`	`toString()`
`String`	`toStringWithHeader()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - ResourceClass
```
public ResourceClass(org.apache.uima.ducc.common.utils.DuccProperties props,
             long share_quantum)
```
- Method Detail
  - authorized
```
public boolean authorized(String user)
```
  - setNodepool
```
public void setNodepool(org.apache.uima.ducc.rm.scheduler.NodePool np)
```
  - getNodepool
```
public org.apache.uima.ducc.rm.scheduler.NodePool getNodepool()
```
  - getTimestamp
```
public long getTimestamp()
```
  - setPureFairShare
```
public void setPureFairShare(int pfs)
```
  - getPureFairShare
```
public int getPureFairShare()
```
  - isExpandByDoubling
```
public boolean isExpandByDoubling()
```
  - setExpandByDoubling
```
public void setExpandByDoubling(boolean ebd)
```
  - getInitializationCap
```
public int getInitializationCap()
```
  - setInitializationCap
```
public void setInitializationCap(int c)
```
  - isUsePrediction
```
public boolean isUsePrediction()
```
  - getPredictionFudge
```
public long getPredictionFudge()
```
  - enforceMemory
```
public boolean enforceMemory()
```
  - getPolicy
```
public SchedConstants.Policy getPolicy()
```
  - setTrueCap
```
public void setTrueCap(int cap)
```
  - getTrueCap
```
public int getTrueCap()
```
  - getAllotment
```
public int getAllotment(IRmJob j)
```
  - getName
```
public String getName()
```
    public String getId() { return id; }
  - getShareWeight
```
public int getShareWeight()
```
  - allotmentExceeded
```
public boolean allotmentExceeded(IRmJob j)
```
    Does this job push the per-user allotment over the top? Note that we don't store current occupancy directly, we always calculate it from the jobs assigned to the class. Less bookkeeping that way. UIMA-4275
  - fairShareCapExceeded
```
public boolean fairShareCapExceeded(IRmJob j)
```
  - getEffectiveWeight
```
public int getEffectiveWeight(int order)
```
    Return my share weight, if I have any jobs of the given order or less. If not, return 0;
  - canUseBonus
```
public boolean canUseBonus(int order)
```
    Can I use more 1 more share of this size? This is more complex than for Users and Jobs because in addition to checking if my request is filled, we need to make sure the underlying nodepools can support the bonus. (This creates an upper bound on apportionment from this class that tends to trickle down into users and jobs as the counting progresses). UIMA-4065
    
    Parameters:
    order - The size of the available share. Must be an exact match because the offerer has already done all reasonable splitting and will have a better use for it if I can't take it. The decision is based on the wbo/gbo arrays that the offer has been building up just before asking this question.
    
    Returns:
    True if I can use the share, false otherwise.
  - getPriority
```
public int getPriority()
```
  - clearShares
```
public void clearShares()
```
  - initWantedByOrder
```
public void initWantedByOrder(ResourceClass unused)
```
  - getWantedByOrder
```
public int[] getWantedByOrder()
```
  - getGivenByOrder
```
public int[] getGivenByOrder()
```
  - setGivenByOrder
```
public void setGivenByOrder(int[] gbo)
```
  - calculateCap
```
public int calculateCap()
```
  - hasSharesGiven
```
public boolean hasSharesGiven()
```
  - getDashes
```
public static String getDashes()
```
  - getHeader
```
public static String getHeader()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toStringWithHeader
```
public String toStringWithHeader()
```
  - getApportionmentSorter
```
public Comparator<org.apache.uima.ducc.rm.scheduler.IEntity> getApportionmentSorter()
```

Class ResourceClass

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.uima.ducc.rm.scheduler.SchedConstants

Field Summary

Fields inherited from interface org.apache.uima.ducc.rm.scheduler.SchedConstants

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ResourceClass

Method Detail

authorized

setNodepool

getNodepool

getTimestamp

setPureFairShare

getPureFairShare

isExpandByDoubling

setExpandByDoubling

getInitializationCap

setInitializationCap

isUsePrediction

getPredictionFudge

enforceMemory

getPolicy

setTrueCap

getTrueCap

getAllotment

getName

getShareWeight

allotmentExceeded

fairShareCapExceeded

getEffectiveWeight

canUseBonus

getPriority

clearShares

initWantedByOrder

getWantedByOrder

getGivenByOrder

setGivenByOrder

calculateCap

hasSharesGiven

getDashes

getHeader

hashCode

toString

toStringWithHeader

getApportionmentSorter