| `memory_heuristics` | Default memory size weightings, described below under "Default Memory Sizes".

| `heap` | The maximum heap size to use. It may be a single value such as `64m` or a range of acceptable values such as `128m..256m`. It is used to calculate the value of the Java command line option `-Xmx`.

| `metaspace` | The maximum Metaspace size to use. It is applicable to versions of OpenJDK from 1.8 onwards. It may be a single value such as `64m` or a range of acceptable values such as `128m..256m`. It is used to calculate the value of the Java command line option `-XX:MaxMetaspaceSize=`.

| `permgen` | The maximum PermGen size to use. It is applicable to versions of OpenJDK earlier than 1.8. It may be a single value such as `64m` or a range of acceptable values such as `128m..256m`. It is used to calculate the value of the Java command line option `-XX:MaxPermSize=`.

| `stack` | The stack size to use. It may be a single value such as `2m` or a range of acceptable values such as `2m..4m`. It is used to calculate the value of the Java command line option `-Xss`.

| `native` | The amount of memory to reserve for native memory allocation. It should normally be omitted or specified as a range with no upper bound such as `100m..`. It does not correspond to a switch on the Java command line.

Memory sizes together with _memory weightings_ (described in the next section) are used to calculate the amount of memory for each memory type. The calculation is described later.

Memory sizes consist of a non-negative integer followed by a unit (`k` for kilobytes, `m` for megabytes, `g` for gigabytes; the case is not significant). Only the memory size `0` may be specified without a unit.

The above memory size properties may be omitted, specified as a single value, or specified as a range. Ranges use the syntax `<lower bound>..<upper bound>`, although either bound may be omitted in which case the defaults of zero and the total available memory are used for the lower bound and upper bound, respectively. Examples of ranges are `100m..200m` (any value between 100 and 200 megabytes, inclusive) and `100m..` (any value greater than or equal to 100 megabytes).

Each form of memory size is equivalent to a range. Omitting a memory size is equivalent to specifying the range `0..`. Specifying a single value is equivalent to specifying the range with that value as both the lower and upper bound, for example `128m` is equivalent to the range `128m..128m`.

Memory weightings are configured in the `memory_heuristics` mapping of [`config/openjdk.yml`][]. Each weighting is a non-negative number and represents a proportion of the total available memory (represented by the sum of all the weightings). For example, the following weightings:

represent a maximum heap size three times as large as the maximum PermGen size, and so on.

Memory weightings are used together with memory ranges to calculate the amount of memory for each memory type, as follows.

The total available memory is allocated into heap, Metaspace or PermGen (depending on the version of OpenJDK), stack, and native memory types.

The total available memory is allocated to each memory type in proportion to its weighting. If the resultant size of a memory type lies outside its range, the size is constrained to

the range, the constrained size is excluded from the remaining memory, and no further calculation is required for the memory type. If the resultant size of a memory size lies within its range, the size is included in the remaining memory. The remaining memory is then allocated to the remaining memory types in a similar fashion. Allocation terminates when none of the sizes of the remaining memory types is constrained by the corresponding range.

Termination is guaranteed since there is a finite number of memory types and in each iteration either none of the remaining memory sizes is constrained by the corresponding range and allocation terminates or at least one memory size is constrained by the corresponding range and is omitted from the next iteration.

require 'java_buildpack/jre/memory/memory_range'

# @!attribute [r] range

# @return [MemoryRange] the permissible range of the memory bucket

attr_accessor :range

# @!attribute [r] weighting

# @return [Numeric] the weighting of the memory bucket

attr_reader :weighting

# @param [MemoryRange, nil] range a user-specified range for the memory bucket or nil if the user did not specify a

# range

def initialize(name, weighting, range)

@range = range ? validate_memory_range(range) : nil

def validate_memory_range(range)

raise "Invalid 'range' parameter of class '#{range.class}' for #{identify} : not a MemoryRange" unless range.is_a? MemoryRange

range

raise "Invalid negative $MEMORY_LIMIT #{memory_limit}" if memory_limit_size < 0

require 'java_buildpack/jre'

module JavaBuildpack::Jre

# A class representing a permissible range of memory sizes.

class MemoryRange

# @!attribute [r] floor

# @return [MemorySize] the lower bound of this memory range

attr_reader :floor

# @!attribute [r] ceiling

# @return [MemorySize, nil] the upper bound of this memory range or +nil+ if there is no upper bound

attr_reader :ceiling

# Creates a memory range based on either a memory range string or lower and upper bounds expressed as MemorySizes.

#

# @param [MemorySize, String] value the lower bound of the range or a string range

# @param [MemorySize, nil] ceiling the upper bound of the range

def initialize(value, ceiling = nil)

if value.is_a? String

raise "Invalid combination of parameter types #{value.class} and #{ceiling.class}" unless ceiling.nil?

lower_bound, upper_bound = MemoryRange.get_bounds(value)

@floor = create_memory_size lower_bound

@ceiling = upper_bound ? create_memory_size(upper_bound) : nil

else

MemoryRange.validate_memory_size value

MemoryRange.validate_memory_size ceiling unless ceiling.nil?

@floor = value

@ceiling = ceiling

end

raise "Invalid range: floor #{@floor} is higher than ceiling #{@ceiling}" if @ceiling && @floor > @ceiling

end

# Determines whether or not this range is bounded. Reads better than testing for a +nil+ ceiling.

#

# @return [Boolean] +true+ if and only if this range is bounded

def bounded?

!@ceiling.nil?

end

# Determines whether a given memory size falls in this range.

#

# @param [MemorySize] size the memory size to be checked

# @return [Boolean] +true+ if and only if the given memory size falls in this range

def contains?(size)

@floor <= size && (@ceiling.nil? || size <= @ceiling)

end

# Constrains a given memory size to this range. If the size falls within the range, returns the size.

# If the size is below the range, return the floor of the range. If the size is above the range,

# return the ceiling of the range.

#

# @param [MemorySize] size the memory size to be constrained

# @return [MemorySize] the constrained memory size

def constrain(size)

if size < @floor

@floor

else

!@ceiling.nil? && size > @ceiling ? @ceiling : size

end

end

# Returns true if and only if this range consists of a single value.

#

# @return [Boolean] whether or not this range consists of a single value

def degenerate?

@floor == @ceiling

end

# Multiply this memory range by a numeric factor.

#

# @param [Numeric] other the factor to multiply by

# @return [MemoryRange] the result

def *(other)

raise "Cannot multiply a MemoryRange by an instance of #{other.class}" unless other.is_a? Numeric

raise 'Cannot multiply an unbounded MemoryRange by 0' if !bounded? && other == 0

MemoryRange.new(@floor * other, bounded? ? @ceiling * other : nil)

end

# Compare this memory range for equality with another memory range

#

# @param [MemoryRange] other

# @return [Boolean] the result

def ==(other)

@floor == other.floor && @ceiling == other.ceiling

end

# Returns a string representation of this range.

#

# @return [String] the string representation of this range

def to_s

"#{@floor}..#{@ceiling ? @ceiling : ''}"

end

private

RANGE_SEPARATOR = '..'

def self.get_bounds(range)

if range.index(RANGE_SEPARATOR)

lower_bound, upper_bound = range.split(RANGE_SEPARATOR)

lower_bound = '0' if lower_bound.nil? || lower_bound == ''

return lower_bound, upper_bound

else

return range, range

end

end

def create_memory_size(size)

MemorySize.new(size)

end

def self.validate_memory_size(size)

raise "Invalid MemorySize parameter of type #{size.class}" unless size.is_a? MemorySize

end

end