/*
+
+ private static String ADJUSTMENT_MESSAGE = null;
* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
* Copyright (C) $$Year-Rel$$ The Jalview Authors
*
* @author bsoares
*
*/
-import java.util.Locale;
-
public class MemorySetting
{
public static final String MAX_HEAPSIZE_PERCENT_PROPERTY_NAME = "jvmmempc";
private static final long NOMEM_MAX_HEAPSIZE_GB_DEFAULT = 8;
+ public static final String NS = "MEMORY";
+
+ public static final String CUSTOMISED_SETTINGS = NS
+ + "_CUSTOMISED_SETTINGS";
+
+ public static final String MEMORY_JVMMEMPC = NS + "_"
+ + MAX_HEAPSIZE_PERCENT_PROPERTY_NAME.toUpperCase();
+
+ public static final String MEMORY_JVMMEMMAX = NS + "_"
+ + MAX_HEAPSIZE_PROPERTY_NAME.toUpperCase();
+
protected static boolean logToClassChecked = false;
+ public static String memorySuffixes = "bkmgt"; // order of the suffixes is
+ // important!
+
public static long getMemorySetting()
{
return getMemorySetting(null, null);
}
+ public static long getMemorySetting(String jvmmemmaxarg,
+ String jvmmempcarg)
+ {
+ return getMemorySetting(jvmmemmaxarg, jvmmempcarg, true, false);
+ }
+
/**
* Decide on appropriate memory setting for Jalview based on the two arguments
* values: jvmmempc - the maximum percentage of total physical memory to
* @param jvmmempcarg
* Max percentage of physical memory to use. Defaults to "90".
*
+ * @param useProps
+ * boolean to decide whether to look at System properties.
+ *
* @return The amount of memory (in bytes) to allocate to Jalview
*/
public static long getMemorySetting(String jvmmemmaxarg,
- String jvmmempcarg)
+ String jvmmempcarg, boolean useProps, boolean quiet)
{
// actual Xmx value-to-be
long maxMemLong = -1;
+ clearAdjustmentMessage();
// (absolute) jvmmaxmem setting, start with default
long memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
- if (jvmmemmaxarg == null)
+ if (jvmmemmaxarg == null && useProps)
{
jvmmemmaxarg = System.getProperty(MAX_HEAPSIZE_PROPERTY_NAME);
}
String jvmmemmax = jvmmemmaxarg;
if (jvmmemmax != null && jvmmemmax.length() > 0)
{
- long multiplier = 1;
- switch (jvmmemmax.toLowerCase(Locale.ROOT).substring(jvmmemmax.length() - 1))
- {
- case "t":
- multiplier = 1099511627776L; // 2^40
- jvmmemmax = jvmmemmax.substring(0, jvmmemmax.length() - 1);
- break;
- case "g":
- multiplier = 1073741824; // 2^30
- jvmmemmax = jvmmemmax.substring(0, jvmmemmax.length() - 1);
- break;
- case "m":
- multiplier = 1048576; // 2^20
- jvmmemmax = jvmmemmax.substring(0, jvmmemmax.length() - 1);
- break;
- case "k":
- multiplier = 1024; // 2^10
- jvmmemmax = jvmmemmax.substring(0, jvmmemmax.length() - 1);
- break;
- case "b":
- multiplier = 1; // 2^0
- jvmmemmax = jvmmemmax.substring(0, jvmmemmax.length() - 1);
- break;
- default:
- break;
- }
-
// parse the arg
try
{
- memmax = Long.parseLong(jvmmemmax);
+ memmax = memoryStringToLong(jvmmemmax);
+ if (memmax == 0)
+ {
+ throw (new NumberFormatException("Not allowing 0"));
+ }
} catch (NumberFormatException e)
{
memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
- System.out.println("MemorySetting Property '"
+ setAdjustmentMessage("MemorySetting Property '"
+ 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 = 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
- {
- memmax = multiplier * memmax;
+ + "') badly formatted or 0, using default ("
+ + MAX_HEAPSIZE_GB_DEFAULT + "g).", quiet);
}
// check at least minimum value (this accounts for negatives too)
if (memmax < APPLICATION_MIN_MEMORY)
{
memmax = APPLICATION_MIN_MEMORY;
- System.out.println("MemorySetting Property '"
+ setAdjustmentMessage("MemorySetting Property '"
+ MAX_HEAPSIZE_PROPERTY_NAME + "' (" + jvmmemmaxarg
+ ") too small, using minimum (" + APPLICATION_MIN_MEMORY
- + ").");
+ + ").", quiet);
}
}
else
{
// no need to warn if no setting
- // System.out.println("MemorySetting Property '" + maxHeapSizeProperty
+ // adjustmentMessage("MemorySetting Property '" + maxHeapSizeProperty
// + "' not
// set.");
}
// get max percent of physical memory, starting with default
float percent = MAX_HEAPSIZE_PERCENT_DEFAULT;
- if (jvmmempcarg == null)
+ if (jvmmempcarg == null && useProps)
{
jvmmempcarg = System.getProperty(MAX_HEAPSIZE_PERCENT_PROPERTY_NAME);
}
{
if (jvmmempc != null)
{
- float trypercent = Float.parseFloat(jvmmempc);
- if (0 < trypercent && trypercent <= 100f)
+ int trypercent = Integer.parseInt(jvmmempc);
+ if (0 <= trypercent && trypercent <= 100)
{
percent = trypercent;
}
else
{
- System.out.println("MemorySetting Property '"
+ setAdjustmentMessage("MemorySetting Property '"
+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME
- + "' should be in range 1..100. Using default " + percent
- + "%");
+ + "' should be in range 0..100. Using default " + percent
+ + "%", quiet);
}
}
} catch (NumberFormatException e)
{
- System.out.println("MemorySetting property '"
+ setAdjustmentMessage("MemorySetting property '"
+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' (" + jvmmempcarg
- + ") badly formatted");
+ + ") badly formatted", quiet);
}
// catch everything in case of no com.sun.management.OperatingSystemMXBean
{
mempc = physicalMem - LEAVE_FREE_MIN_MEMORY;
reducedmempc = true;
- System.out.println("MemorySetting Property '"
+ setAdjustmentMessage("MemorySetting Property '"
+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' (" + jvmmempcarg
+ ") too large. Leaving free space for OS and reducing to ("
- + mempc + ").");
+ + mempc + ").", quiet);
}
// check for minimum application memsize
{
if (reducedmempc)
{
- System.out.println("Reduced MemorySetting (" + mempc
+ setAdjustmentMessage("Reduced MemorySetting (" + mempc
+ ") too small. Increasing to application minimum ("
- + APPLICATION_MIN_MEMORY + ").");
+ + APPLICATION_MIN_MEMORY + ").", quiet);
}
else
{
- System.out.println("MemorySetting Property '"
+ setAdjustmentMessage("MemorySetting Property '"
+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' ("
+ jvmmempcarg + ") too small. Using minimum ("
- + APPLICATION_MIN_MEMORY + ").");
+ + APPLICATION_MIN_MEMORY + ").", quiet);
}
mempc = APPLICATION_MIN_MEMORY;
}
{
// not enough memory for application, just try and grab what we can!
mempc = physicalMem;
- System.out.println(
+ setAdjustmentMessage(
"Not enough physical memory for application. Ignoring MemorySetting Property '"
+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' ("
+ jvmmempcarg
+ "). Using maximum memory available ("
- + physicalMem + ").");
+ + physicalMem + ").",
+ quiet);
}
} catch (Throwable t)
{
memoryPercentError = true;
- System.out.println(
- "Problem calling GetMemory.getPhysicalMemory(). Likely to be problem with com.sun.management.OperatingSystemMXBean");
+ setAdjustmentMessage(
+ "Problem calling GetMemory.getPhysicalMemory(). Likely to be problem with com.sun.management.OperatingSystemMXBean",
+ quiet);
t.printStackTrace();
}
// == null))
&& memmax > NOMEM_MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE)
{
- System.out.println(
+ setAdjustmentMessage(
"Capping maximum memory to " + NOMEM_MAX_HEAPSIZE_GB_DEFAULT
- + "g due to failure to read physical memory size.");
+ + "g due to failure to read physical memory size.",
+ quiet);
memmax = NOMEM_MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
}
return maxMemLong;
}
-}
\ No newline at end of file
+ public static boolean isValidMemoryString(String text)
+ {
+ if (text.length() > 0)
+ {
+ char lastChar = text.charAt(text.length() - 1);
+ char[] otherChars = text.substring(0, text.length() - 1)
+ .toCharArray();
+ for (char c : otherChars)
+ {
+ if (c < '0' || c > '9')
+ {
+ return false;
+ }
+ }
+ if ((lastChar < '0' || lastChar > '9') && memorySuffixes
+ .indexOf(Character.toLowerCase(lastChar)) == -1)
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static long memoryStringToLong(String memString)
+ throws NumberFormatException
+ {
+ if (!isValidMemoryString(memString)) // not valid
+ {
+ throw (new NumberFormatException("Not a valid memory string"));
+ }
+ char suffix = Character
+ .toLowerCase(memString.charAt(memString.length() - 1));
+ if ('0' <= suffix && suffix <= '9') // no suffix
+ {
+ return Long.valueOf(memString);
+ }
+ if (memorySuffixes.indexOf(suffix) == -1) // suffix is unknown
+ {
+ return -1;
+ }
+
+ long multiplier = (long) Math.pow(2,
+ memorySuffixes.indexOf(suffix) * 10); // note order of suffixes in
+ // memorySuffixes important
+ // here!
+ // parse the arg. NumberFormatExceptions passed on to calling method
+ long mem = Long
+ .parseLong(memString.substring(0, memString.length() - 1));
+ if (mem == 0)
+ {
+ return 0;
+ }
+
+ // apply multiplier only if result is not too big (i.e. bigger than a long)
+ if (Long.MAX_VALUE / mem > multiplier)
+ {
+ return multiplier * mem;
+ }
+ else
+ {
+ // number too big for a Long. Limit to Long.MAX_VALUE
+ System.out.println("Memory parsing of '" + memString
+ + "' produces number too big. Limiting to Long.MAX_VALUE="
+ + Long.MAX_VALUE);
+ return Long.MAX_VALUE;
+ }
+ }
+
+ public static String memoryLongToString(long mem)
+ {
+ return memoryLongToString(mem, "%.3f");
+ }
+
+ public static String memoryLongToString(long mem, String format)
+ {
+ int exponent = 0;
+ float num = mem;
+ char suffix = 'b';
+
+ for (int i = 0; i < memorySuffixes.length(); i++)
+ {
+ char s = Character.toUpperCase(memorySuffixes.charAt(i));
+ if (mem < (long) Math.pow(2, exponent + 10)
+ || i == memorySuffixes.length() - 1) // last suffix
+ {
+ suffix = s;
+ num = (float) (mem / Math.pow(2, exponent));
+ break;
+ }
+ exponent += 10;
+ }
+
+ return String.format(format, num) + suffix;
+ }
+
+ private static String ADJUSTMENT_MESSAGE = null;
+
+ private static void setAdjustmentMessage(String reason, boolean quiet)
+ {
+ ADJUSTMENT_MESSAGE = reason;
+ if (!quiet)
+ {
+ System.out.println(reason);
+ }
+ }
+
+ public static void clearAdjustmentMessage()
+ {
+ ADJUSTMENT_MESSAGE = null;
+ }
+
+ public static String getAdjustmentMessage()
+ {
+ return ADJUSTMENT_MESSAGE;
+ }
+
+}
git://source.jalview.org / jalview.git / blobdiff