NodeAllocationAlgorithm (mws)

Overview

Package

Class

Deprecated

Index

Help

Groovy Documentation

FRAMES NO FRAMES

SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD

DETAIL: ENUM CONSTANTS | FIELD | METHOD

com.ace.mws.policies
[Groovy] Enum NodeAllocationAlgorithm

java.lang.Object
  com.ace.mws.policies.NodeAllocationAlgorithm

enum NodeAllocationAlgorithm

Represents the algorithm used to allocate Nodes when the NodeAllocationPolicy is used.

Authors:: jpratt

Enum Constant Summary
`Contiguous` This algorithm allocates nodes in contiguous (linear) blocks as required by the Compaq RMS system.
`CustomPriority` This algorithm allows a site to specify the priority of various static and dynamic aspects of compute nodes and allocate them with preference for higher priority nodes.
`InReportedOrder` Simple first come, first served algorithm where nodes are allocated in the order they are presented by the resource manager.
`InReverseReportedOrder` The default setting.
`MinimumConfiguredResources` This algorithm prioritizes nodes according to the configured resources on each node.
`NONE`
`NodeSpeed` This algorithm selects nodes in the order of fastest node first order.
`ProcessorLoad` Nodes are selected that have the maximum amount of available, unused CPU power (<#of CPU's> - ).
`ProcessorSpeedBalance` This algorithm attempts to allocate the most balanced set of nodes possible to a job.

Field Summary
`private String`	`moabString`
`private String`	`str`

Constructor Summary
`private NodeAllocationAlgorithm(String str)`

Method Summary
`String`	`toMoabString()`
`String`	`toString()`
`NodeAllocationAlgorithm`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`NodeAllocationAlgorithm[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class Object
wait, wait, wait, equals, toString, hashCode, getClass, notify, notifyAll

Enum Constant Detail

Contiguous

NodeAllocationAlgorithm Contiguous

This algorithm allocates nodes in contiguous (linear) blocks as required by the Compaq RMS system.

CustomPriority

NodeAllocationAlgorithm CustomPriority

This algorithm allows a site to specify the priority of various static and dynamic aspects of compute nodes and allocate them with preference for higher priority nodes. It is highly flexible allowing node attribute and usage information to be combined with reservation affinity. Using node allocation priority, you can specify the node priority with GlobalNodeAllocationPolicy.globalCustomPriorityFunction.

InReportedOrder

NodeAllocationAlgorithm InReportedOrder

Simple first come, first served algorithm where nodes are allocated in the order they are presented by the resource manager. This is a very simple, and very fast algorithm.

InReverseReportedOrder

NodeAllocationAlgorithm InReverseReportedOrder

The default setting. Nodes are allocated in descending order that they are presented by the resource manager, or the reverse of FIRSTAVAILABLE.

MinimumConfiguredResources

NodeAllocationAlgorithm MinimumConfiguredResources

This algorithm prioritizes nodes according to the configured resources on each node. Those nodes with the fewest configured resources that still meet the job's resource constraints are selected.

NONE

NodeAllocationAlgorithm NONE

NodeSpeed

NodeAllocationAlgorithm NodeSpeed

This algorithm selects nodes in the order of fastest node first order. Nodes are selected by node speed if specified. If node speed is not specified, nodes are selected by processor speed. If neither is specified, nodes are selected in a random order.

ProcessorLoad

NodeAllocationAlgorithm ProcessorLoad

Nodes are selected that have the maximum amount of available, unused CPU power (<#of CPU's> - ). ProcessorLoad is a good algorithm for timesharing node systems and applies to jobs starting immediately. For the purpose of future reservations, the MinimumConfiguredResources algorithm is used.

ProcessorSpeedBalance

NodeAllocationAlgorithm ProcessorSpeedBalance

This algorithm attempts to allocate the most balanced set of nodes possible to a job. In most cases, but not all, the metric for balance of the nodes is node procspeed. Thus, if possible, nodes with identical procspeeds are allocated to the job. If identical procspeed nodes cannot be found, the algorithm allocates the set of nodes with the minimum node procspeed span or range.

Field Detail

moabString

private String moabString

str

private String str

Constructor Detail