X-Git-Url: http://source.jalview.org/gitweb/?p=jalview.git;a=blobdiff_plain;f=getdown%2Fsrc%2Fgetdown%2Fcore%2Fsrc%2Fmain%2Fjava%2Fjalview%2Fbin%2FMemorySetting.java;h=55e304da531bdea8e4b81408149c63a8991dfd00;hp=5d7f14c83deeeb30747461324f56a9b7614f62b4;hb=726bda0e9aea2d68b90803e142346cc46c8d4772;hpb=9bcd0b0ffcccc233c93ac761084dd8bfa7c5fd5a

diff --git a/getdown/src/getdown/core/src/main/java/jalview/bin/MemorySetting.java b/getdown/src/getdown/core/src/main/java/jalview/bin/MemorySetting.java
index 5d7f14c..55e304d 100644
--- a/getdown/src/getdown/core/src/main/java/jalview/bin/MemorySetting.java
+++ b/getdown/src/getdown/core/src/main/java/jalview/bin/MemorySetting.java
@@ -1,4 +1,6 @@
 /*
+
+  private static String ADJUSTMENT_MESSAGE = null;
  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
  * Copyright (C) $$Year-Rel$$ The Jalview Authors
  * 
@@ -31,6 +33,7 @@ package jalview.bin;
  * @author bsoares
  *
  */
+
 public class MemorySetting
 {
   public static final String MAX_HEAPSIZE_PERCENT_PROPERTY_NAME = "jvmmempc";
@@ -49,13 +52,33 @@ public class MemorySetting
 
   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
@@ -83,99 +106,66 @@ public class MemorySetting
    * @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().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);
     }
@@ -185,24 +175,24 @@ public class MemorySetting
     {
       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
@@ -223,10 +213,10 @@ public class MemorySetting
         {
           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
@@ -234,16 +224,16 @@ public class MemorySetting
         {
           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;
         }
@@ -252,19 +242,21 @@ public class MemorySetting
       {
         // 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();
     }
 
@@ -281,9 +273,10 @@ public class MemorySetting
                                                               // == 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;
     }
 
@@ -299,4 +292,120 @@ public class MemorySetting
     return maxMemLong;
   }
 
+  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, "%.1f");
+  }
+
+  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;
+  }
+
 }
\ No newline at end of file