X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FMemorySetting.java;h=5d7f14c83deeeb30747461324f56a9b7614f62b4;hb=5d501d5230ad1c42f1e17a485cb86a04ba8b538a;hp=117be25aab7ac8f49ea880293d8c0ae9e95e9356;hpb=ab5e23473401e82bdc96056751d7a1c184b59ba6;p=jalview.git diff --git a/src/jalview/bin/MemorySetting.java b/src/jalview/bin/MemorySetting.java index 117be25..5d7f14c 100644 --- a/src/jalview/bin/MemorySetting.java +++ b/src/jalview/bin/MemorySetting.java @@ -1,3 +1,23 @@ +/* + * 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 . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.bin; /** @@ -13,19 +33,21 @@ package jalview.bin; */ 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; @@ -39,28 +61,27 @@ public class MemorySetting * 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 */ @@ -71,10 +92,10 @@ public class MemorySetting 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) @@ -112,22 +133,21 @@ public class MemorySetting 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 { @@ -135,14 +155,13 @@ public class MemorySetting } // 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 + + ")."); } } @@ -155,10 +174,10 @@ public class MemorySetting } // 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; @@ -173,18 +192,17 @@ public class MemorySetting } 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 @@ -192,7 +210,7 @@ public class MemorySetting 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 @@ -201,33 +219,33 @@ public class MemorySetting // 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 @@ -236,7 +254,7 @@ public class MemorySetting 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 + ")."); @@ -254,16 +272,19 @@ public class MemorySetting // 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