HVAllocationOvercommitPolicy (mws)

Overview

Package

Class

Deprecated

Index

Help

Groovy Documentation

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.ace.mws.policies
[Groovy] Class HVAllocationOvercommitPolicy

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

class HVAllocationOvercommitPolicy

The Hypervisor Allocation Overcommit policy controls how many virtual machines can be placed on a hypervisor. By enabling this policy, you are allowing Moab to allocate more resoures to a set of virtual machines than a hypervisor may actually have. This is possible due to virtualization. In other words, this policy allows you to set the high-water mark for virtual machine allocation for hypervisors. At least one of these limits must be greater than 1.0, or the policy will not be able to set to a state of PolicyState.ENABLED.

This class inherits fields from Policy.

Authors:: bsaville

See Also:: Policy

Field Summary
`private Boolean`	`conflicted`
`private String`	`description`
`private String`	`id`
`private Double`	`memoryAllocationLimit` Setting this to 1 effectively disables the allocation overcommit based on memory.
`private String`	`name`
`private Set`	`potentialConflicts` (String collection)
`private Integer`	`priority`
`private Double`	`processorAllocationLimit` The Allocation Limit defines the upper bound or maximum amount of VCPUs that can be created on any given hypervisor (HV).
`private PolicyState`	`state`
`private Set`	`tags` (String collection)
`private Set`	`types` (String collection)

Constructor Summary
`HVAllocationOvercommitPolicy()`

Method Summary
`Boolean`	`getConflicted()`
`String`	`getDescription()`
`String`	`getId()`
`Double`	`getMemoryAllocationLimit()` Setting this to 1 effectively disables the allocation overcommit based on memory.
`String`	`getName()`
`Set`	`getPotentialConflicts()` (String collection)
`Integer`	`getPriority()`
`Double`	`getProcessorAllocationLimit()` The Allocation Limit defines the upper bound or maximum amount of VCPUs that can be created on any given hypervisor (HV).
`PolicyState`	`getState()`
`Set`	`getTags()` (String collection)
`Set`	`getTypes()` (String collection)
`void`	`setConflicted(Boolean conflicted)`
`void`	`setDescription(String description)`
`void`	`setId(String id)`
`void`	`setMemoryAllocationLimit(Double memoryAllocationLimit)` Setting this to 1 effectively disables the allocation overcommit based on memory.
`void`	`setName(String name)`
`void`	`setPotentialConflicts(Set potentialConflicts)` (String collection)
`void`	`setPriority(Integer priority)`
`void`	`setProcessorAllocationLimit(Double processorAllocationLimit)` The Allocation Limit defines the upper bound or maximum amount of VCPUs that can be created on any given hypervisor (HV).
`void`	`setState(PolicyState state)`
`void`	`setTags(Set tags)` (String collection)
`void`	`setTypes(Set types)` (String collection)
`String`	`toString()`

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

Field Detail

conflicted

private Boolean conflicted

description

private String description

id

private String id

memoryAllocationLimit

private Double memoryAllocationLimit

Setting this to 1 effectively disables the allocation overcommit based on memory. If this and processorAllocationLimit are both set to 1.0 (the default), the policy state cannot be set to PolicyState.ENABLED.

name

private String name

potentialConflicts

private Set potentialConflicts

(String collection)

priority

private Integer priority

processorAllocationLimit

private Double processorAllocationLimit

The Allocation Limit defines the upper bound or maximum amount of VCPUs that can be created on any given hypervisor (HV). For example, if you have a hypervisor with 12 processors or cores (Moab sees them as 12 processors), and have an Allocation Limit of 2.0 for procs, then Moab will not allow, under any condition, more than 24 VCPU's to be allocated on this hypervisor. Remember: a VM can have one or more VCPU's. So, in this example, the HV could only support 8 VM's if they all had 3 VPCU's each. It could support 4 VM's if they had 6 VPCU's each, and so forth From http://www.adaptivecomputing.com/resources/docs/mwm/7-1-1/Content/topics/vm/allocation_limits_and_utilization_threshold.html Setting this to 1 effectively disables the allocation overcommit based on processors. If this and memoryAllocationLimit are both set to 1.0 (the default), the policy state cannot be set to PolicyState.ENABLED.

state

private PolicyState state

types

private Set types

(String collection)

Constructor Detail