364 lines
13 KiB
Java
364 lines
13 KiB
Java
/*
|
|
* Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code 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
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package nsk.share.gc;
|
|
|
|
import nsk.share.*;
|
|
|
|
/**
|
|
* Parser for GC tests' arguments.
|
|
* <p>
|
|
* <code>ArgumentHandler</code> handles specific command line arguments
|
|
* related to way of execution of a test in addition to general arguments
|
|
* recognized by {@link ArgumentParser <code>ArgumentParser</code>}.
|
|
* <p>
|
|
* Following is the list of specific options for <code>ArgumentHandler</code>:
|
|
* <ul>
|
|
* <li><code>-iterations="<i>value</i>"</code>, where <i>value</i> must either
|
|
* be "infinity", or an integer number, greater than 0. This parameter
|
|
* specifies the number of iterations to run the testcase. If the value is
|
|
* "infinity", then the test will be run for at least <code>gcTimeout</code>
|
|
* minutes. Otherwise, the testcase will be repeated for
|
|
* <code>iterations</code> times.
|
|
* <li><code>-gcTimeout="<i>value</i>"</code>, where <i>value</i> must be an
|
|
* integer number, greater than 0. If <i>infinity</i> is set to
|
|
* <code>iterations</code>, then the test consider <code>gcTimeout</code>
|
|
* argument to run the test for at least specified number of minutes.
|
|
* <li><code>-threads="<i>value</i>"</code>, where <i>value</i> must be an
|
|
* integer number, greater than 0. A user may specify the number of threads
|
|
* to start in the test with that paramenter. However, a test may ignore
|
|
* this value, if it does know the number of threads to start. It
|
|
* depends on a test: read its README file.
|
|
* <li><code>-memoryEater="<i>value</i>"</code>, where <i>value</i> must be
|
|
* either "single", or "multi" string. This argument specifies if a single
|
|
* thread should be used to eat the whole heap or not. If "multi" string is
|
|
* assigned to <code>-memoryEater</code>, then a number of threads will be
|
|
* started to eat the heap. The number is equal to number of available
|
|
* processors plus 1.
|
|
* <li><code>-largeClassesPath="<i>value</i>"</code>, where <i>value</i> is a
|
|
* directory to load large classes from.
|
|
* <li><code>-fieldsLimitation="<i>value</i>"</code>, where <i>value</i> must
|
|
* be either "over", or "under" string. This argument specifies what classes
|
|
* should be loaded from <code>largeClassesPath</code> directory. If
|
|
* <i>over</i> is set, then the classes that have number of fileds over
|
|
* JVM limitation should be loaded, otherwise -- classes that have number
|
|
* of fileds under limitation.
|
|
* </ul>
|
|
* @see ArgumentParser
|
|
*/
|
|
public class ArgumentHandler extends ArgumentParser {
|
|
|
|
// Define all possible arguments
|
|
private final static String ITERATIONS = "iterations";
|
|
private final static String AGGREGATION_DEPTH = "aggregationDepth";
|
|
private final static String GC_TIMEOUT = "gcTimeout";
|
|
private final static String THREADS = "threads";
|
|
private final static String MEM_EATER = "memoryEater";
|
|
private final static String LARGE_CLASSES_PATH = "largeClassesPath";
|
|
private final static String FIELDS_LIMITATION = "fieldsLimitation";
|
|
|
|
// An acceptible value for ITERATIONS
|
|
private final static String INFINITY = "infinity";
|
|
|
|
// Acceptible values for MEM_EATER
|
|
private final static String ME_SINGLE = "single";
|
|
private final static String ME_MULTI = "multi";
|
|
|
|
// Acceptible values for FIELDS_LIMITATION
|
|
private final static String FL_OVER = "over";
|
|
private final static String FL_UNDER = "under";
|
|
|
|
/**
|
|
* Keep a copy of raw command-line arguments and parse them;
|
|
* but throw an exception on parsing error.
|
|
*
|
|
* @param args Array of the raw command-line arguments.
|
|
*
|
|
* @throws BadOption If unknown option or illegal option value found
|
|
*
|
|
* @see ArgumentParser
|
|
*/
|
|
public ArgumentHandler(String args[]) {
|
|
super(args);
|
|
}
|
|
|
|
/**
|
|
* Returns number of iterations.
|
|
* <p>
|
|
* If <code>-iterations="<i>infinity</i>"</code>, the method returns -1.
|
|
* If the argument is not set, the method returns 1. Otherwise, the
|
|
* specified number is returned.
|
|
*
|
|
* @return number of iterations.
|
|
*
|
|
*/
|
|
public int getIterations() {
|
|
String value = options.getProperty(ITERATIONS, "1");
|
|
|
|
if (INFINITY.equals(value))
|
|
return -1;
|
|
|
|
try {
|
|
return Integer.parseInt(value);
|
|
} catch (NumberFormatException e) {
|
|
throw new TestBug("Not an integer value of \"" + ITERATIONS
|
|
+ "\" argument: " + value);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the depth of object aggregation.
|
|
* <p>
|
|
* If the argument is not set, the method returns 0. Otherwise, the
|
|
* specified number is returned.
|
|
*
|
|
* @return number of aggregation depth.
|
|
*
|
|
*/
|
|
public int getAggregationDepth() {
|
|
String value = options.getProperty(AGGREGATION_DEPTH, "0");
|
|
|
|
try {
|
|
return Integer.parseInt(value);
|
|
} catch (NumberFormatException e) {
|
|
throw new TestBug("Not an integer value of \"" + AGGREGATION_DEPTH
|
|
+ "\" argument: " + value);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns number of minutes to run the test.
|
|
* <p>
|
|
* @return number of minutes to run the test.
|
|
*
|
|
*/
|
|
public int getGCTimeout() {
|
|
String value = options.getProperty(GC_TIMEOUT);
|
|
|
|
try {
|
|
return Integer.parseInt(value);
|
|
} catch (NumberFormatException e) {
|
|
throw new TestBug("\"" + GC_TIMEOUT + "\" argument is not defined "
|
|
+ "or is not integer: " + value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a directory to load large classes from.
|
|
* <p>
|
|
* @return a directory to load large classes from.
|
|
*
|
|
*/
|
|
public String getLargeClassesPath() {
|
|
return options.getProperty(LARGE_CLASSES_PATH);
|
|
}
|
|
|
|
/**
|
|
* Returns number of threads to start in a test. If <code>threads</code>
|
|
* is not set, the method returns specified number of threads.
|
|
* <p>
|
|
* @param defaultValue default value, if <code>threads</code> is not set.
|
|
* @return number of threads to start in a test.
|
|
*
|
|
*/
|
|
public int getThreads(int defaultValue) {
|
|
String value = options.getProperty(THREADS);
|
|
|
|
if (value == null)
|
|
return defaultValue;
|
|
|
|
try {
|
|
return Integer.parseInt(value);
|
|
} catch (NumberFormatException e) {
|
|
throw new TestBug("Not an integer value of \"" + THREADS
|
|
+ "\" argument: " + value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if single thread should be used to eat the whole heap,
|
|
* false otherwise.
|
|
*
|
|
* @return true if single thread should be used to eat the whole heap,
|
|
* false otherwise.
|
|
*
|
|
*/
|
|
public boolean isSingleMemoryEater() {
|
|
String value = options.getProperty(MEM_EATER);
|
|
|
|
if (value == null)
|
|
return true;
|
|
else if (value.equals(ME_SINGLE))
|
|
return true;
|
|
else if (value.equals(ME_MULTI))
|
|
return false;
|
|
else
|
|
throw new TestBug("Value for \"" + MEM_EATER + "\" must be either "
|
|
+ ME_SINGLE + ", or " + ME_MULTI);
|
|
}
|
|
|
|
/**
|
|
* Returns true if classes with number of fileds over limitation should be
|
|
* loaded, false otherwise.
|
|
*
|
|
* @return true if classes with number of fileds over limitation should be
|
|
* loaded, false otherwise.
|
|
*
|
|
*/
|
|
public boolean isOverFieldsLimitation() {
|
|
String value = options.getProperty(FIELDS_LIMITATION);
|
|
|
|
if (value == null)
|
|
return false;
|
|
else if (value.equals(FL_OVER))
|
|
return true;
|
|
else if (value.equals(FL_UNDER))
|
|
return false;
|
|
else
|
|
throw new TestBug("Value for \"" + FIELDS_LIMITATION + "\" must be "
|
|
+ "either " + FL_OVER + ", or " + FL_UNDER);
|
|
}
|
|
|
|
/**
|
|
* Checks if an option is allowed and has proper value.
|
|
* This method is invoked by <code>parseArguments()</code>
|
|
*
|
|
* @param option option name
|
|
* @param value string representation of value
|
|
* (could be an empty string too)
|
|
* null if this option has no value
|
|
* @return <i>true</i> if option is allowed and has proper value,
|
|
* <i>false</i> if option is not admissible
|
|
*
|
|
* @throws <i>BadOption</i> if option has an illegal value
|
|
*
|
|
* @see #parseArguments()
|
|
*/
|
|
protected boolean checkOption(String option, String value) {
|
|
|
|
// Define iterations
|
|
if (option.equals(ITERATIONS)) {
|
|
if (INFINITY.equals(value))
|
|
return true;
|
|
|
|
try {
|
|
int number = Integer.parseInt(value);
|
|
|
|
if (number < 1)
|
|
throw new BadOption(option + ": value must be greater than "
|
|
+ "zero.");
|
|
} catch (NumberFormatException e) {
|
|
throw new BadOption("Value for option \"" + option + "\" must "
|
|
+ "be integer or \"" + INFINITY + "\": "
|
|
+ value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Define timeout
|
|
if (option.equals(GC_TIMEOUT)) {
|
|
try {
|
|
int number = Integer.parseInt(value);
|
|
|
|
if (number < 0)
|
|
throw new BadOption(option + ": value must be a positive "
|
|
+ "integer");
|
|
} catch (NumberFormatException e) {
|
|
throw new BadOption("Value for option \"" + option + "\" must "
|
|
+ "be integer: " + value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Define threads
|
|
if (option.equals(THREADS)) {
|
|
try {
|
|
int number = Integer.parseInt(value);
|
|
|
|
if (number < 0)
|
|
throw new BadOption(option + ": value must be a positive "
|
|
+ "integer");
|
|
} catch (NumberFormatException e) {
|
|
throw new BadOption("Value for option \"" + option + "\" must "
|
|
+ "be integer: " + value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Define path to large classes
|
|
if (option.equals(LARGE_CLASSES_PATH))
|
|
return true;
|
|
|
|
// Define memory eater
|
|
if (option.equals(MEM_EATER)) {
|
|
if ( (ME_SINGLE.equals(value)) || (ME_MULTI.equals(value)) )
|
|
return true;
|
|
else
|
|
throw new BadOption("Value for option \"" + option + "\" must "
|
|
+ "be either " + ME_SINGLE + ", or "
|
|
+ ME_MULTI + ": " + value);
|
|
}
|
|
|
|
// Define fields limitation
|
|
if (option.equals(FIELDS_LIMITATION)) {
|
|
if ( (FL_OVER.equals(value)) || (FL_UNDER.equals(value)) )
|
|
return true;
|
|
else
|
|
throw new BadOption("Value for option \"" + option + "\" must "
|
|
+ "be either " + FL_OVER + ", or "
|
|
+ FL_UNDER + ": " + value);
|
|
}
|
|
|
|
// Define aggregationDepth
|
|
if (option.equals(AGGREGATION_DEPTH)) {
|
|
try {
|
|
int number = Integer.parseInt(value);
|
|
|
|
if (number < 0)
|
|
throw new BadOption(option + ": value must be a positive "
|
|
+ "integer");
|
|
} catch (NumberFormatException e) {
|
|
throw new BadOption("Value for option \"" + option + "\" must "
|
|
+ "be integer: " + value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return super.checkOption(option, value);
|
|
}
|
|
|
|
/**
|
|
* Checks if the values of all options are consistent.
|
|
* This method is invoked by <code>parseArguments()</code>
|
|
*
|
|
* @throws <i>BadOption</i> if options have inconsistent values
|
|
*
|
|
* @see ArgumentParser#parseArguments()
|
|
*/
|
|
protected void checkOptions() {
|
|
super.checkOptions();
|
|
}
|
|
} // ArgumentHandler
|