Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
MemorySetting	40	98	50	0.621794962.2%	Show methods

Class MemorySetting

Class MemorySetting	Line # 40	Total Statements 98	Complexity 50	TOTAL Coverage 0.621794962.2%
getMemorySetting() : long   getMemorySetting() : long	7676	1.01	1.01	1.0 1.0100%
getMemorySetting(String,String) : long   getMemorySetting(String,String) : long	8181	1.01	1.01	1.0 1.0100%
getMemorySetting(String,String,boolean,boolean) : long   getMemorySetting(String,String,boolean,boolean) : long	119119	55.055	25.025	0.7037037 0.703703770.4%
isValidMemoryString(String) : boolean   isValidMemoryString(String) : boolean	300300	9.09	7.07	0.6666667 0.666666766.7%
memoryStringToLong(String) : long   memoryStringToLong(String) : long	323323	15.015	7.07	0.64 0.6464%
memoryLongToString(long) : String   memoryLongToString(long) : String	368368	1.01	1.01	0.0 0.00%
memoryLongToString(long,String) : String   memoryLongToString(long,String) : String	373373	11.011	4.04	0.0 0.00%
setAdjustmentMessage(String,boolean) : void   setAdjustmentMessage(String,boolean) : void	397397	3.03	2.02	0.8 0.880%
clearAdjustmentMessage() : void   clearAdjustmentMessage() : void	406406	1.01	1.01	1.0 1.0100%
getAdjustmentMessage() : String   getAdjustmentMessage() : String	411411	1.01	1.01	0.0 0.00%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.6217949	jalview.bin.MemorySettingTest.testGetMemorySettingjalview.bin.MemorySettingTest.testGetMemorySetting	1PASS

 

Source view

1		/*
2
3		private static String ADJUSTMENT_MESSAGE = null;
4		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
5		* Copyright (C) $$Year-Rel$$ The Jalview Authors
6		*
7		* This file is part of Jalview.
8		*
9		* Jalview is free software: you can redistribute it and/or
10		* modify it under the terms of the GNU General Public License
11		* as published by the Free Software Foundation, either version 3
12		* of the License, or (at your option) any later version.
13		*
14		* Jalview is distributed in the hope that it will be useful, but
15		* WITHOUT ANY WARRANTY; without even the implied warranty
16		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
17		* PURPOSE. See the GNU General Public License for more details.
18		*
19		* You should have received a copy of the GNU General Public License
20		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
21		* The Jalview Authors are detailed in the 'AUTHORS' file.
22		*/
23		package jalview.bin;
24
25		import java.util.Locale;
26
27		import jalview.util.ErrorLog;
28
29		/**
30		* Methods to decide on appropriate memory setting for Jalview based on two
31		* optionally provided values: jvmmempc - the maximum percentage of total
32		* physical memory to allocate, and jvmmemmax - the maximum absolute amount of
33		* physical memory to allocate. These can be provided as arguments or system
34		* properties. Other considerations such as minimum application requirements and
35		* leaving space for OS are used too.
36		*
37		* @author bsoares
38		*
39		*/
		62.2% Uncovered Elements: 59 (156) Complexity: 50 Complexity Density: 0.51
40		public class MemorySetting
41		{
42		// This must match the value of Arg.JVMMEMPC.getName()
43		public static final String MAX_HEAPSIZE_PERCENT_PROPERTY_NAME = "jvmmempc";
44
45		// This must match the value of Arg.JVMMEMMAX.getName()
46		public static final String MAX_HEAPSIZE_PROPERTY_NAME = "jvmmemmax";
47
48		private static final int MAX_HEAPSIZE_PERCENT_DEFAULT = 90; // 90%
49
50		private static final long GIGABYTE = 1073741824; // 1GB
51
52		public static final long LEAVE_FREE_MIN_MEMORY = GIGABYTE / 2;
53
54		public static final long APPLICATION_MIN_MEMORY = GIGABYTE / 2;
55
56		private static final long MAX_HEAPSIZE_GB_DEFAULT = 32;
57
58		private static final long NOMEM_MAX_HEAPSIZE_GB_DEFAULT = 8;
59
60		public static final String NS = "MEMORY";
61
62		public static final String CUSTOMISED_SETTINGS = NS
63		+ "_CUSTOMISED_SETTINGS";
64
65		public static final String MEMORY_JVMMEMPC = NS + "_"
66		+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME.toUpperCase(Locale.ROOT);
67
68		public static final String MEMORY_JVMMEMMAX = NS + "_"
69		+ MAX_HEAPSIZE_PROPERTY_NAME.toUpperCase(Locale.ROOT);
70
71		protected static boolean logToClassChecked = false;
72
73		public static String memorySuffixes = "bkmgt"; // order of the suffixes is
74		// important!
75
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
76	1	public static long getMemorySetting()...
77		{
78	1	return getMemorySetting(null, null);
79		}
80
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
81	16	public static long getMemorySetting(String jvmmemmaxarg,...
82		String jvmmempcarg)
83		{
84	16	return getMemorySetting(jvmmemmaxarg, jvmmempcarg, true, false);
85		}
86
87		/**
88		* Decide on appropriate memory setting for Jalview based on the two arguments
89		* values: jvmmempc - the maximum percentage of total physical memory to
90		* allocate, and jvmmemmax - the maximum absolute amount of physical memory to
91		* allocate. These can be provided as arguments. If not provided as arguments
92		* (or set as null) system properties will be used instead (if set). The
93		* memory setting returned will be the lower of the two values. If either of
94		* the values are not provided then defaults will be used (jvmmempc=90,
95		* jvmmemmax=32GB). If total physical memory can't be ascertained when
96		* jvmmempc was set or neither jvmmempc nor jvmmemmax were set, then jvmmemmax
97		* defaults to a much safer 8GB. In this case explicitly setting jvmmemmax and
98		* not setting jvmmempc can set a higher memory for Jalview. The calculation
99		* also tries to ensure 0.5GB memory for the OS, but also tries to ensure at
100		* least 0.5GB memory for Jalview (which takes priority over the OS) If there
101		* is less then 0.5GB of physical memory then the total physical memory is
102		* used for Jalview.
103		*
104		* @param jvmmemmaxarg
105		* Maximum value of memory to set. This can be a numeric string
106		* optionally followed by "b", "k", "m", "g", "t" (case insensitive)
107		* to indicate bytes, kilobytes, megabytes, gigabytes, terabytes
108		* respectively. If null a default value of 32G will be used. If null
109		* and either physical memory can't be determined then the default is
110		* 8GB.
111		* @param jvmmempcarg
112		* Max percentage of physical memory to use. Defaults to "90".
113		*
114		* @param useProps
115		* boolean to decide whether to look at System properties.
116		*
117		* @return The amount of memory (in bytes) to allocate to Jalview
118		*/
		70.4% Uncovered Elements: 24 (81) Complexity: 25 Complexity Density: 0.45
119	16	public static long getMemorySetting(String jvmmemmaxarg,...
120		String jvmmempcarg, boolean useProps, boolean quiet)
121		{
122		// actual Xmx value-to-be
123	16	long maxMemLong = -1;
124	16	clearAdjustmentMessage();
125
126		// (absolute) jvmmaxmem setting, start with default
127	16	long memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
128	16	if (jvmmemmaxarg == null && useProps)
129		{
130	1	jvmmemmaxarg = System.getProperty(MAX_HEAPSIZE_PROPERTY_NAME);
131		}
132	16	String jvmmemmax = jvmmemmaxarg;
133	16	if (jvmmemmax != null && jvmmemmax.length() > 0)
134		{
135		// parse the arg
136	15	try
137		{
138	15	memmax = memoryStringToLong(jvmmemmax);
139	15	if (memmax == 0)
140		{
141	0	throw (new NumberFormatException("Not allowing 0"));
142		}
143		} catch (NumberFormatException e)
144		{
145	0	memmax = MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
146	0	setAdjustmentMessage("MemorySetting Property '"
147		+ MAX_HEAPSIZE_PROPERTY_NAME + "' (" + jvmmemmaxarg
148		+ "') badly formatted or 0, using default ("
149		+ MAX_HEAPSIZE_GB_DEFAULT + "g).", quiet);
150		}
151
152		// check at least minimum value (this accounts for negatives too)
153	15	if (memmax < APPLICATION_MIN_MEMORY)
154		{
155	1	memmax = APPLICATION_MIN_MEMORY;
156	1	setAdjustmentMessage("MemorySetting Property '"
157		+ MAX_HEAPSIZE_PROPERTY_NAME + "' (" + jvmmemmaxarg
158		+ ") too small, using minimum (" + APPLICATION_MIN_MEMORY
159		+ ").", quiet);
160		}
161
162		}
163		else
164		{
165		// no need to warn if no setting
166		// adjustmentMessage("MemorySetting Property '" + maxHeapSizeProperty
167		// + "' not
168		// set.");
169		}
170
171		// get max percent of physical memory, starting with default
172	16	float percent = MAX_HEAPSIZE_PERCENT_DEFAULT;
173	16	if (jvmmempcarg == null && useProps)
174		{
175	1	jvmmempcarg = System.getProperty(MAX_HEAPSIZE_PERCENT_PROPERTY_NAME);
176		}
177	16	String jvmmempc = jvmmempcarg;
178	16	long mempc = -1;
179	16	try
180		{
181	16	if (jvmmempc != null)
182		{
183	15	int trypercent = Integer.parseInt(jvmmempc);
184	14	if (0 <= trypercent && trypercent <= 100)
185		{
186	14	percent = trypercent;
187		}
188		else
189		{
190	0	setAdjustmentMessage("MemorySetting Property '"
191		+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME
192		+ "' should be in range 0..100. Using default " + percent
193		+ "%", quiet);
194		}
195		}
196		} catch (NumberFormatException e)
197		{
198	1	setAdjustmentMessage("MemorySetting property '"
199		+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' (" + jvmmempcarg
200		+ ") badly formatted", quiet);
201		}
202
203		// catch everything in case of no com.sun.management.OperatingSystemMXBean
204	16	boolean memoryPercentError = false;
205	16	try
206		{
207	16	long physicalMem = GetMemory.getPhysicalMemory();
208	16	if (physicalMem > APPLICATION_MIN_MEMORY)
209		{
210		// try and set at least applicationMinMemory and thereafter ensure
211		// leaveFreeMinMemory is left for the OS
212
213	16	mempc = (long) ((physicalMem / 100F) * percent);
214
215		// check for memory left for OS
216	16	boolean reducedmempc = false;
217	16	if (physicalMem - mempc < LEAVE_FREE_MIN_MEMORY)
218		{
219	12	mempc = physicalMem - LEAVE_FREE_MIN_MEMORY;
220	12	reducedmempc = true;
221	12	setAdjustmentMessage("MemorySetting Property '"
222		+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' (" + jvmmempcarg
223		+ ") too large. Leaving free space for OS and reducing to ("
224		+ mempc + ").", quiet);
225		}
226
227		// check for minimum application memsize
228	16	if (mempc < APPLICATION_MIN_MEMORY)
229		{
230	0	if (reducedmempc)
231		{
232	0	setAdjustmentMessage("Reduced MemorySetting (" + mempc
233		+ ") too small. Increasing to application minimum ("
234		+ APPLICATION_MIN_MEMORY + ").", quiet);
235		}
236		else
237		{
238	0	setAdjustmentMessage("MemorySetting Property '"
239		+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' ("
240		+ jvmmempcarg + ") too small. Using minimum ("
241		+ APPLICATION_MIN_MEMORY + ").", quiet);
242		}
243	0	mempc = APPLICATION_MIN_MEMORY;
244		}
245		}
246		else
247		{
248		// not enough memory for application, just try and grab what we can!
249	0	mempc = physicalMem;
250	0	setAdjustmentMessage(
251		"Not enough physical memory for application. Ignoring MemorySetting Property '"
252		+ MAX_HEAPSIZE_PERCENT_PROPERTY_NAME + "' ("
253		+ jvmmempcarg
254		+ "). Using maximum memory available ("
255		+ physicalMem + ").",
256		quiet);
257		}
258
259		} catch (Throwable t)
260		{
261	0	memoryPercentError = true;
262	0	setAdjustmentMessage(
263		"Problem calling GetMemory.getPhysicalMemory(). Likely to be problem with com.sun.management.OperatingSystemMXBean",
264		quiet);
265	0	t.printStackTrace();
266		}
267
268		// In the case of an error reading the percentage of physical memory (when
269		// jvmmempc was set OR neither jvmmempc nor jvmmemmax were set), let's cap
270		// maxMemLong to 8GB
271	16	if (memoryPercentError && mempc == -1
272		&& !(jvmmempcarg == null && jvmmemmaxarg != null) // the same as
273		// (jvmmempcarg !=
274		// null ||
275		// (jvmmempcarg ==
276		// null &&
277		// jvmmemmaxarg
278		// == null))
279		&& memmax > NOMEM_MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE)
280		{
281	0	setAdjustmentMessage(
282		"Capping maximum memory to " + NOMEM_MAX_HEAPSIZE_GB_DEFAULT
283		+ "g due to failure to read physical memory size.",
284		quiet);
285	0	memmax = NOMEM_MAX_HEAPSIZE_GB_DEFAULT * GIGABYTE;
286		}
287
288	16	if (mempc == -1) // percentage memory not set
289		{
290	0	maxMemLong = memmax;
291		}
292		else
293		{
294	16	maxMemLong = Math.min(mempc, memmax);
295		}
296
297	16	return maxMemLong;
298		}
299
		66.7% Uncovered Elements: 5 (15) Complexity: 7 Complexity Density: 0.78
300	15	public static boolean isValidMemoryString(String text)...
301		{
302	15	if (text.length() > 0)
303		{
304	15	char lastChar = text.charAt(text.length() - 1);
305	15	char[] otherChars = text.substring(0, text.length() - 1)
306		.toCharArray();
307	15	for (char c : otherChars)
308		{
309	59	if (c < '0' || c > '9')
310		{
311	0	return false;
312		}
313		}
314	15	if ((lastChar < '0' || lastChar > '9') && memorySuffixes
315		.indexOf(Character.toLowerCase(lastChar)) == -1)
316		{
317	0	return false;
318		}
319		}
320	15	return true;
321		}
322
		64% Uncovered Elements: 9 (25) Complexity: 7 Complexity Density: 0.47
323	15	public static long memoryStringToLong(String memString)...
324		throws NumberFormatException
325		{
326	15	if (!isValidMemoryString(memString)) // not valid
327		{
328	0	throw (new NumberFormatException("Not a valid memory string"));
329		}
330	15	char suffix = Character
331		.toLowerCase(memString.charAt(memString.length() - 1));
332	15	if ('0' <= suffix && suffix <= '9') // no suffix
333		{
334	1	return Long.valueOf(memString);
335		}
336	14	if (memorySuffixes.indexOf(suffix) == -1) // suffix is unknown
337		{
338	0	return -1;
339		}
340
341	14	long multiplier = (long) Math.pow(2,
342		memorySuffixes.indexOf(suffix) * 10); // note order of suffixes in
343		// memorySuffixes important
344		// here!
345		// parse the arg. NumberFormatExceptions passed on to calling method
346	14	long mem = Long
347		.parseLong(memString.substring(0, memString.length() - 1));
348	14	if (mem == 0)
349		{
350	0	return 0;
351		}
352
353		// apply multiplier only if result is not too big (i.e. bigger than a long)
354	14	if (Long.MAX_VALUE / mem > multiplier)
355		{
356	14	return multiplier * mem;
357		}
358		else
359		{
360		// number too big for a Long. Limit to Long.MAX_VALUE
361	0	ErrorLog.outPrintln("Memory parsing of '" + memString
362		+ "' produces number too big. Limiting to Long.MAX_VALUE="
363		+ Long.MAX_VALUE);
364	0	return Long.MAX_VALUE;
365		}
366		}
367
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
368	0	public static String memoryLongToString(long mem)...
369		{
370	0	return memoryLongToString(mem, "%.3f");
371		}
372
		0% Uncovered Elements: 15 (15) Complexity: 4 Complexity Density: 0.36
373	0	public static String memoryLongToString(long mem, String format)...
374		{
375	0	int exponent = 0;
376	0	float num = mem;
377	0	char suffix = 'b';
378
379	0	for (int i = 0; i < memorySuffixes.length(); i++)
380		{
381	0	char s = Character.toUpperCase(memorySuffixes.charAt(i));
382	0	if (mem < (long) Math.pow(2, exponent + 10)
383		|| i == memorySuffixes.length() - 1) // last suffix
384		{
385	0	suffix = s;
386	0	num = (float) (mem / Math.pow(2, exponent));
387	0	break;
388		}
389	0	exponent += 10;
390		}
391
392	0	return String.format(format, num) + suffix;
393		}
394
395		private static String ADJUSTMENT_MESSAGE = null;
396
		80% Uncovered Elements: 1 (5) Complexity: 2 Complexity Density: 0.67
397	14	private static void setAdjustmentMessage(String reason, boolean quiet)...
398		{
399	14	ADJUSTMENT_MESSAGE = reason;
400	14	if (!quiet)
401		{
402	14	ErrorLog.outPrintln(reason);
403		}
404		}
405
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
406	16	public static void clearAdjustmentMessage()...
407		{
408	16	ADJUSTMENT_MESSAGE = null;
409		}
410
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
411	0	public static String getAdjustmentMessage()...
412		{
413	0	return ADJUSTMENT_MESSAGE;
414		}
415
416		}