+/*
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
+ *
+ * This file is part of Jalview.
+ *
+ * Jalview is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * Jalview is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
package jalview.bin;
/**
* @author bsoares
*
*/
+import java.util.Locale;
+
public class MemorySetting
{
- public static final long leaveFreeMinMemory = 536870912; // 0.5 GB
+ public static final String MAX_HEAPSIZE_PERCENT_PROPERTY_NAME = "jvmmempc";
+
+ public static final String MAX_HEAPSIZE_PROPERTY_NAME = "jvmmemmax";
- public static final long applicationMinMemory = 536870912; // 0.5 GB
+ private static final int MAX_HEAPSIZE_PERCENT_DEFAULT = 90; // 90%
- private final static int maxHeapSizePerCentDefault = 90;
+ private static final long GIGABYTE = 1073741824; // 1GB
- public final static String maxHeapSizePerCentPropertyName = "jvmmempc";
+ public static final long LEAVE_FREE_MIN_MEMORY = GIGABYTE / 2;
- private final static long maxHeapSizeDefault = 34359738368L; // 32GB
+ public static final long APPLICATION_MIN_MEMORY = GIGABYTE / 2;
- private final static long noMemMaxHeapSizeDefault = 8589934592L; // 8GB
+ private static final long MAX_HEAPSIZE_GB_DEFAULT = 32;
- public final static String maxHeapSizePropertyName = "jvmmemmax";
+ private static final long NOMEM_MAX_HEAPSIZE_GB_DEFAULT = 8;
protected static boolean logToClassChecked = false;
* values: jvmmempc - the maximum percentage of total physical memory to
* allocate, and jvmmemmax - the maximum absolute amount of physical memory to
* allocate. These can be provided as arguments. If not provided as arguments
- * (or set as null) system properties will be used instead (if set). The memory
- * setting returned will be the lower of the two values. If either of the values
- * are not provided then defaults will be used (jvmmempc=90, jvmmemmax=32GB). If
- * total physical memory can't be ascertained when jvmmempc was set or neither
- * jvmmempc nor jvmmemmax were set, then jvmmemmax defaults to a much safer 8GB.
- * In this case explicitly setting jvmmemmax and not setting jvmmempc can set a
- * higher memory for Jalview. The calculation also tries to ensure 0.5GB memory
- * for the OS, but also tries to ensure at least 0.5GB memory for Jalview (which
- * takes priority over the OS) If there is less then 0.5GB of physical memory
- * then the total physical memory is used for Jalview.
+ * (or set as null) system properties will be used instead (if set). The
+ * memory setting returned will be the lower of the two values. If either of
+ * the values are not provided then defaults will be used (jvmmempc=90,
+ * jvmmemmax=32GB). If total physical memory can't be ascertained when
+ * jvmmempc was set or neither jvmmempc nor jvmmemmax were set, then jvmmemmax
+ * defaults to a much safer 8GB. In this case explicitly setting jvmmemmax and
+ * not setting jvmmempc can set a higher memory for Jalview. The calculation
+ * also tries to ensure 0.5GB memory for the OS, but also tries to ensure at
+ * least 0.5GB memory for Jalview (which takes priority over the OS) If there
+ * is less then 0.5GB of physical memory then the total physical memory is
+ * used for Jalview.
*
* @param jvmmemmaxarg
- * Maximum value of memory to set. This can be a numeric
- * string optionally followed by "b", "k", "m", "g", "t"
- * (case insensitive) to indicate bytes, kilobytes,
- * megabytes, gigabytes, terabytes respectively. If null a
- * default value of 32G will be used. If null and either
- * physical memory can't be determined then the default is
- * 8GB.
+ * Maximum value of memory to set. This can be a numeric string
+ * optionally followed by "b", "k", "m", "g", "t" (case insensitive)
+ * to indicate bytes, kilobytes, megabytes, gigabytes, terabytes
+ * respectively. If null a default value of 32G will be used. If null
+ * and either physical memory can't be determined then the default is
+ * 8GB.
* @param jvmmempcarg
- * Max percentage of physical memory to use. Defaults to
- * "90".
+ * Max percentage of physical memory to use. Defaults to "90".
*
* @return The amount of memory (in bytes) to allocate to Jalview
*/
long maxMemLong = -1;
// (absolute) jvmmaxmem setting, start with default
- long memmax = maxHeapSizeDefault;
+ long memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
if (jvmmemmaxarg == null)
{
- jvmmemmaxarg = System.getProperty(maxHeapSizePropertyName);
+ jvmmemmaxarg = System.getProperty(MAX_HEAPSIZE_PROPERTY_NAME);
}
String jvmmemmax = jvmmemmaxarg;
if (jvmmemmax != null && jvmmemmax.length() > 0)
{
long multiplier = 1;
- switch (jvmmemmax.toLowerCase().substring(jvmmemmax.length() - 1))
+ switch (jvmmemmax.toLowerCase(Locale.ROOT).substring(jvmmemmax.length() - 1))
{
case "t":
multiplier = 1099511627776L; // 2^40
memmax = Long.parseLong(jvmmemmax);
} catch (NumberFormatException e)
{
- memmax = maxHeapSizeDefault;
+ memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
System.out.println("MemorySetting Property '"
- + maxHeapSizePropertyName
- + "' ("
- + jvmmemmaxarg + "') badly formatted, using default ("
- + memmax + ").");
+ + MAX_HEAPSIZE_PROPERTY_NAME + "' (" + jvmmemmaxarg
+ + "') badly formatted, using default ("
+ + MAX_HEAPSIZE_GB_DEFAULT + "g).");
}
// apply multiplier if not too big (i.e. bigger than a long)
if (Long.MAX_VALUE / memmax < multiplier)
{
- memmax = maxHeapSizeDefault;
- System.out.println(
- "MemorySetting Property '" + maxHeapSizePropertyName + "' ("
- + jvmmemmaxarg
- + ") too big, using default (" + memmax + ").");
+ memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
+ System.out.println("MemorySetting Property '"
+ + MAX_HEAPSIZE_PROPERTY_NAME + "' (" + jvmmemmaxarg
+ + ") too big, using default (" + MAX_HEAPSIZE_GB_DEFAULT
+ + "g).");
}
else
{
}
// check at least minimum value (this accounts for negatives too)
- if (memmax < applicationMinMemory)
+ if (memmax < APPLICATION_MIN_MEMORY)
{
- memmax = applicationMinMemory;
- System.out.println(
- "MemorySetting Property '" + maxHeapSizePropertyName + "' ("
- + jvmmemmaxarg
- + ") too small, using minimum ("
- + applicationMinMemory + ").");
+ memmax = APPLICATION_MIN_MEMORY;
+ System.out.println("MemorySetting Property '"
+ + MAX_HEAPSIZE_PROPERTY_NAME + "' (" + jvmmemmaxarg
+ + ") too small, using minimum (" + APPLICATION_MIN_MEMORY
+ + ").");
}
}
}
// get max percent of physical memory, starting with default
- float percent = maxHeapSizePerCentDefault;
+ float percent = MAX_HEAPSIZE_PERCENT_DEFAULT;
if (jvmmempcarg == null)
{
- jvmmempcarg = System.getProperty(maxHeapSizePerCentPropertyName);
+ jvmmempcarg = System.getProperty(MAX_HEAPSIZE_PERCENT_PROPERTY_NAME);
}
String jvmmempc = jvmmempcarg;
long mempc = -1;
}
else
{
- System.out.println(
- "MemorySetting Property '"
- + maxHeapSizePerCentPropertyName
- + "' should be in range 1..100. Using default "
- + percent + "%");
+ System.out.println("MemorySetting Property '"
+ + MAX_HEAPSIZE_PERCENT_PROPERTY_NAME
+ + "' should be in range 1..100. Using default " + percent
+ + "%");
}
}
} catch (NumberFormatException e)
{
- System.out.println(
- "MemorySetting property '" + maxHeapSizePerCentPropertyName
- + "' (" + jvmmempcarg + ") badly formatted");
+ System.out.println("MemorySetting property '"
+ + MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' (" + jvmmempcarg
+ + ") badly formatted");
}
// catch everything in case of no com.sun.management.OperatingSystemMXBean
try
{
long physicalMem = GetMemory.getPhysicalMemory();
- if (physicalMem > applicationMinMemory)
+ if (physicalMem > APPLICATION_MIN_MEMORY)
{
// try and set at least applicationMinMemory and thereafter ensure
// leaveFreeMinMemory is left for the OS
// check for memory left for OS
boolean reducedmempc = false;
- if (physicalMem - mempc < leaveFreeMinMemory)
+ if (physicalMem - mempc < LEAVE_FREE_MIN_MEMORY)
{
- mempc = physicalMem - leaveFreeMinMemory;
+ mempc = physicalMem - LEAVE_FREE_MIN_MEMORY;
reducedmempc = true;
System.out.println("MemorySetting Property '"
- + maxHeapSizePerCentPropertyName + "' (" + jvmmempcarg
+ + MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' (" + jvmmempcarg
+ ") too large. Leaving free space for OS and reducing to ("
+ mempc + ").");
}
// check for minimum application memsize
- if (mempc < applicationMinMemory)
+ if (mempc < APPLICATION_MIN_MEMORY)
{
if (reducedmempc)
{
System.out.println("Reduced MemorySetting (" + mempc
+ ") too small. Increasing to application minimum ("
- + applicationMinMemory + ").");
+ + APPLICATION_MIN_MEMORY + ").");
}
else
{
System.out.println("MemorySetting Property '"
- + maxHeapSizePerCentPropertyName + "' (" + jvmmempcarg
- + ") too small. Using minimum (" + applicationMinMemory
- + ").");
+ + MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' ("
+ + jvmmempcarg + ") too small. Using minimum ("
+ + APPLICATION_MIN_MEMORY + ").");
}
- mempc = applicationMinMemory;
+ mempc = APPLICATION_MIN_MEMORY;
}
}
else
mempc = physicalMem;
System.out.println(
"Not enough physical memory for application. Ignoring MemorySetting Property '"
- + maxHeapSizePerCentPropertyName + "' ("
+ + MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' ("
+ jvmmempcarg
+ "). Using maximum memory available ("
+ physicalMem + ").");
// jvmmempc was set OR neither jvmmempc nor jvmmemmax were set), let's cap
// maxMemLong to 8GB
if (memoryPercentError && mempc == -1
- // && (jvmmempcarg != null || (jvmmempcarg == null && jvmmemmaxarg == null))
- // the above is easier to understand but simplified to
- && !(jvmmempcarg == null && jvmmemmaxarg != null)
- && memmax > noMemMaxHeapSizeDefault)
+ && !(jvmmempcarg == null && jvmmemmaxarg != null) // the same as
+ // (jvmmempcarg !=
+ // null ||
+ // (jvmmempcarg ==
+ // null &&
+ // jvmmemmaxarg
+ // == null))
+ && memmax > NOMEM_MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE)
{
System.out.println(
- "Capping maximum memory to "
- + (noMemMaxHeapSizeDefault + 536870912) / 1073741824 // this is the nearest integer GB for noMemMaxHeapSizeDefault
- + "GB due to failure to read physical memory size.");
- memmax = noMemMaxHeapSizeDefault;
+ "Capping maximum memory to " + NOMEM_MAX_HEAPSIZE_GB_DEFAULT
+ + "g due to failure to read physical memory size.");
+ memmax = NOMEM_MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
}
if (mempc == -1) // percentage memory not set
git://source.jalview.org / jalview.git / blobdiff