285 lines
10 KiB
Java
285 lines
10 KiB
Java
/*
|
|
* Copyright (c) 1998, 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 jit.graph;
|
|
import java.io.*;
|
|
import java.util.*;
|
|
import java.lang.*;
|
|
import java.lang.reflect.*;
|
|
import nsk.share.TestFailure;
|
|
|
|
|
|
public final class Globals
|
|
{
|
|
// Minimum and Maximum number of threads
|
|
public static int NUM_THREADS = 1;
|
|
public static long RANDOM_SEED = System.currentTimeMillis();
|
|
public static int STATIC_LOOP = 0;
|
|
public static int NUM_TEST_CLASSES = 7;
|
|
public static long RANDOM_LOOP = 100;
|
|
public static boolean VERBOSE = false;
|
|
private static Random indexGenerator = null;
|
|
|
|
//private static TestLoader CGTTestLoader = null;
|
|
private static String [] ClassArray = null;
|
|
private static Class [] ClassInstanceArray = null;
|
|
private static int maxClassIndex = 0;
|
|
|
|
private static String [] MethodName_Array = null;
|
|
private static Method [] MethodInstance_Array = null;
|
|
|
|
//Should be prime, so that odds of an incorrect verification reduced
|
|
public static int [] MethodID_Array = null;
|
|
|
|
|
|
//Number of threads will be reduced as threads finish
|
|
public static synchronized void decNumThreads(){NUM_THREADS--;};
|
|
|
|
public static synchronized void initialize(String testListPath)
|
|
{
|
|
|
|
File td = new File (testListPath);
|
|
if (!td.exists())
|
|
{
|
|
System.err.println("File " + testListPath + " Not found");
|
|
System.exit(1);
|
|
}
|
|
if (!td.isFile())
|
|
{
|
|
System.err.println(testListPath + " Must be a File");
|
|
System.exit(1);
|
|
}
|
|
|
|
BufferedReader classList = null;
|
|
|
|
try
|
|
{
|
|
classList = new BufferedReader(new FileReader(td));
|
|
}
|
|
catch (FileNotFoundException fnfx)
|
|
{
|
|
System.err.println("Error finding Classlist");
|
|
System.exit(1);
|
|
}
|
|
|
|
String line = null;
|
|
try
|
|
{
|
|
line = classList.readLine();
|
|
}
|
|
catch (IOException iox)
|
|
{
|
|
System.err.println("Error reading Classlist");
|
|
System.exit(1);
|
|
}
|
|
|
|
try
|
|
{
|
|
maxClassIndex = Math.abs(Integer.parseInt(line));//ClassArray.length;
|
|
}
|
|
catch (NumberFormatException nfx)
|
|
{
|
|
System.err.println("Error reading Classlist - first number must be number of methods defined");
|
|
System.exit(1);
|
|
}
|
|
|
|
ClassArray = new String [maxClassIndex];
|
|
ClassInstanceArray = new Class [maxClassIndex];
|
|
MethodName_Array = new String [maxClassIndex];
|
|
MethodInstance_Array = new Method [maxClassIndex];
|
|
MethodID_Array = new int [maxClassIndex];
|
|
|
|
int i;
|
|
for (i = 0; (i<maxClassIndex) && (line != null); i++)
|
|
{
|
|
try
|
|
{
|
|
line = classList.readLine();
|
|
}
|
|
catch (IOException iox)
|
|
{
|
|
System.err.println("Error reading ClasslistFile: testListPath");
|
|
System.exit(1);
|
|
}
|
|
StringTokenizer lineTokens = new StringTokenizer(line, "\t ");
|
|
if (lineTokens.countTokens() <3)
|
|
{
|
|
System.out.println("Error reading ClasslistFile: Errored line");
|
|
i--;
|
|
}
|
|
else
|
|
{
|
|
ClassArray[i] = lineTokens.nextToken();
|
|
MethodName_Array[i] =lineTokens.nextToken();
|
|
MethodID_Array[i] = Integer.parseInt(lineTokens.nextToken());
|
|
}
|
|
}
|
|
maxClassIndex = i;
|
|
|
|
indexGenerator = new Random(RANDOM_SEED);
|
|
if ((NUM_TEST_CLASSES < ClassArray.length) && (NUM_TEST_CLASSES > 0))
|
|
maxClassIndex = NUM_TEST_CLASSES;
|
|
else
|
|
NUM_TEST_CLASSES = maxClassIndex;
|
|
}
|
|
|
|
//does a binary serach to find the index for the ID of a method
|
|
private static int ID_BinSearch(int begin, int end, int ID)
|
|
{
|
|
if (end < begin)
|
|
return(-1);
|
|
|
|
int mid = (begin + end)/2;
|
|
int midvalue = MethodID_Array[mid];
|
|
|
|
if (ID == midvalue)
|
|
return (mid);
|
|
else if (ID < midvalue)
|
|
return(ID_BinSearch(begin, mid-1, ID));
|
|
else
|
|
return(ID_BinSearch(mid+1, end, ID));
|
|
}
|
|
|
|
|
|
//based off a static index, this function selects the method to be called
|
|
public static MethodData returnNextStaticMethod(int Method_ID)
|
|
{
|
|
//int i = ID_BinSearch(0, MethodID_Array.length - 1, Method_ID);
|
|
int i = ID_BinSearch(0, maxClassIndex - 1, Method_ID);
|
|
|
|
return(nextStaticMethod((i==-1)?0:i));
|
|
}
|
|
|
|
//this function randomly selects the next method to be called by the test class
|
|
public static MethodData nextRandomMethod()
|
|
{
|
|
|
|
int i = indexGenerator.nextInt(maxClassIndex);
|
|
return(nextStaticMethod(i));
|
|
}
|
|
|
|
private static MethodData nextStaticMethod(int i)
|
|
{
|
|
Class methodsClass = null;
|
|
Method nextMethod = null;
|
|
|
|
try
|
|
{
|
|
//methodsClass = CGTTestLoader.findClass(ClassArray[i]);
|
|
methodsClass = ClassInstanceArray[i];
|
|
if (methodsClass == null)
|
|
{
|
|
methodsClass = Class.forName(ClassArray[i]);
|
|
ClassInstanceArray[i] = methodsClass;
|
|
}
|
|
nextMethod = MethodInstance_Array[i];
|
|
if (nextMethod == null )
|
|
{
|
|
nextMethod =
|
|
methodsClass.getMethod(MethodName_Array[i],
|
|
new Class[]{java.util.Vector.class, java.util.Vector.class,
|
|
java.lang.Long.class, java.lang.Integer.class});
|
|
//sum vector, ID vector, function depth, static function call depth
|
|
MethodInstance_Array[i] = nextMethod;
|
|
}
|
|
}
|
|
catch (ClassNotFoundException cnfx)
|
|
{
|
|
System.out.println("Class: " +ClassArray[i]+ " Not Found");
|
|
System.exit(-1);
|
|
}
|
|
catch (NoSuchMethodException nsmx)
|
|
{
|
|
System.out.println("Class: " +ClassArray[i]);
|
|
System.out.println("Method: " +MethodName_Array[i]+" Not Found");
|
|
System.exit(-1);
|
|
}
|
|
catch (SecurityException sx)
|
|
{
|
|
System.out.println("Class: " +ClassArray[i]);
|
|
System.out.println("Method: " +MethodName_Array[i]);
|
|
System.out.println("Security Exception Generated, by above method call");
|
|
System.exit(-1);
|
|
}
|
|
return(new MethodData(ClassArray[i], MethodName_Array[i], methodsClass, nextMethod, MethodID_Array[i]));
|
|
}
|
|
|
|
|
|
/*These two functions are used to verify that all function were called in the proper order*/
|
|
|
|
//called by "parent" function to add childs ID to vector
|
|
public static void addFunctionIDToVector(int FunctionIndex, Vector IDVector)
|
|
{
|
|
IDVector.addElement(new Integer(FunctionIndex));
|
|
}
|
|
|
|
//called by "child" to add Function Index to Vector
|
|
public static void appendSumToSumationVector(int FunctionIndex, Vector SummationVector)
|
|
{
|
|
if (SummationVector.isEmpty())
|
|
SummationVector.addElement(new Long(FunctionIndex));
|
|
else
|
|
SummationVector.addElement(new Long(((Long)SummationVector.lastElement()).longValue() + FunctionIndex));
|
|
}
|
|
|
|
//This function calls a method based off of MethodData
|
|
public static void callMethod(MethodData methodCallStr,
|
|
Vector summation, Vector ID,
|
|
Long numFcalls, Integer staticFcalls)
|
|
throws InvocationTargetException
|
|
|
|
{
|
|
if(NUM_THREADS >1)
|
|
{
|
|
if ((staticFcalls.intValue() + numFcalls.longValue()) %23 == 0)
|
|
{
|
|
try
|
|
{
|
|
Thread.sleep(225);
|
|
}
|
|
catch (InterruptedException ie)
|
|
{}
|
|
if (VERBOSE)
|
|
System.out.println("\t\tCurrentThread:" + Thread.currentThread().getName());
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
methodCallStr.nextMethod.invoke(methodCallStr.instance,
|
|
new Object []{summation, ID, numFcalls, staticFcalls});
|
|
}
|
|
catch (IllegalAccessException iax) //should never happen with a valid testfile
|
|
{
|
|
throw new TestFailure("Illegal Access Exception");
|
|
}
|
|
/*
|
|
catch (InvocationTargetException itx)
|
|
{
|
|
itx.printStackTrace();
|
|
System.out.println("Invocation Target Exception");
|
|
System.exit(1);
|
|
}*/
|
|
}
|
|
}
|