jdynpur-1.0/src/ 40755 0 0 0 10564300702 10663 5 ustar 0 0 jdynpur-1.0/src/main/ 40755 0 0 0 10564557600 11622 5 ustar 0 0 jdynpur-1.0/src/main/assembly/ 40755 0 0 0 10564300702 13426 5 ustar 0 0 jdynpur-1.0/src/main/bin/ 40755 0 0 0 10564560170 12366 5 ustar 0 0 jdynpur-1.0/src/main/config/ 40755 0 0 0 10564300702 13054 5 ustar 0 0 jdynpur-1.0/src/main/java/ 40755 0 0 0 10526551376 12545 5 ustar 0 0 jdynpur-1.0/src/main/java/java/ 40755 0 0 0 10526551376 13466 5 ustar 0 0 jdynpur-1.0/src/main/java/java/lang/ 40755 0 0 0 10563066014 14376 5 ustar 0 0 jdynpur-1.0/src/main/java/java/lang/jdynpur/ 40755 0 0 0 10564077404 16077 5 ustar 0 0 jdynpur-1.0/src/main/java/org/ 40755 0 0 0 10526551376 13334 5 ustar 0 0 jdynpur-1.0/src/main/java/org/softevo/ 40755 0 0 0 10526551376 15021 5 ustar 0 0 jdynpur-1.0/src/main/java/org/softevo/jdynpur/ 40755 0 0 0 10564100254 16477 5 ustar 0 0 jdynpur-1.0/src/main/java/org/softevo/jdynpur/eval/ 40755 0 0 0 10563064472 17440 5 ustar 0 0 jdynpur-1.0/src/main/java/org/softevo/jdynpur/runtime/ 40755 0 0 0 10530322553 20163 5 ustar 0 0 jdynpur-1.0/src/main/java/org/softevo/jdynpur/util/ 40755 0 0 0 10564100104 17446 5 ustar 0 0 jdynpur-1.0/src/site/ 40755 0 0 0 10564303022 11625 5 ustar 0 0 jdynpur-1.0/src/site/apt/ 40755 0 0 0 10564346474 12433 5 ustar 0 0 jdynpur-1.0/src/site/fml/ 40755 0 0 0 10526551376 12422 5 ustar 0 0 jdynpur-1.0/src/site/resources/ 40755 0 0 0 10526551376 13656 5 ustar 0 0 jdynpur-1.0/src/site/resources/builds/ 40755 0 0 0 10564306534 15134 5 ustar 0 0 jdynpur-1.0/src/site/resources/images/ 40755 0 0 0 10526551376 15123 5 ustar 0 0 jdynpur-1.0/src/site/xdoc/ 40755 0 0 0 10564354740 12577 5 ustar 0 0 jdynpur-1.0/src/test/ 40755 0 0 0 10526551376 11657 5 ustar 0 0 jdynpur-1.0/src/test/java/ 40755 0 0 0 10526551376 12600 5 ustar 0 0 jdynpur-1.0/src/test/java/org/ 40755 0 0 0 10526551376 13367 5 ustar 0 0 jdynpur-1.0/src/test/java/org/softevo/ 40755 0 0 0 10526551376 15054 5 ustar 0 0 jdynpur-1.0/checkstyle.xml 100644 0 0 24311 10564302155 13076 0 ustar 0 0
jdynpur-1.0/pom.xml 100644 0 0 25715 10564560736 11557 0 ustar 0 0
4.0.0de.unisb.cs.stjdynpurJDynpurDynamic Purity Analysis for Java Programs1.0jarhttp://www.st.cs.uni-sb.de/2007dallmeierValentin Dallmeierdallmeier@st.cs.uni-sb.dehttp://www.st.cs.uni-sb.de/~dallmeier/Software Engineering Group at Saarland Universityhttp://www.st.cs.uni-sb.de/2Developergoscinnyscp://ssh.st.cs.uni-sb.de/home/www/models/jdynpurContinuumhttp://kubrick:8080/continuum/mailtruetruetruetrue
dallmeier@st.cs.uni-sb.de
General Public License (GPL)http://www.gnu.org/licenses/gpl.txtmanualscm:svn:svn+ssh://ssh.st.cs.uni-sb.de/home/SVN/dallmeier/devel/asmdynpur/trunkscm:svn:svn+ssh//ssh.st.cs.uni-sb.de/home/SVN/dallmeier/devel/asmdynpur/trunkSoftware Engineering Group at Saarland Universityhttp://www.st.cs.uni-sb.de/org.softevoutil0.1compilejunitjunit3.8.1testcommons-iocommons-io1.0compilecommons-clicommons-cli1.0compileasmasm2.2.1compileasmasm-commons2.2.1compileasmasm-util2.2.1compilest.cs.uni-sb.deSoftware Engineering Chair repositorydefaulthttp://www.st.cs.uni-sb.de/maven2codehaus-m2-repositoryCodehaus Maven 2.x Repositoryhttp://repository.codehaus.orgorg.apache.maven.pluginsmaven-compiler-plugin1.51.5maven-assembly-pluginsrc/main/assembly/bin.xmlsrc/main/assembly/src.xmlorg.apache.maven.pluginsmaven-clover-plugin1.5pre-siteinstrumentorg.codehaus.mojocobertura-maven-plugincleanorg.apache.maven.pluginsmaven-jar-pluginorg.softevo.jdynpur.runtime.OnTheFlyInstrumenterTrueorg.apache.maven.pluginsmaven-project-info-reports-plugincimdependencieslicenseindexsummaryscmproject-teamorg.apache.maven.pluginsmaven-checkstyle-plugincheckstyle.xmlorg.apache.maven.pluginsmaven-clover-pluginorg.codehaus.mojofindbugs-maven-pluginMax1.0-beta-1org.apache.maven.pluginsmaven-javadoc-plugin128m512morg.apache.maven.pluginsmaven-jxr-pluginorg.apache.maven.pluginsmaven-surefire-report-pluginorg.codehaus.mojocobertura-maven-pluginorg.apache.maven.pluginsmaven-pmd-plugintrue1.5org.codehaus.mojotaglist-maven-pluginTODOFIXMEXXX
jdynpur-1.0/src/main/assembly/bin.xml 100644 0 0 3024 10564300702 15014 0 ustar 0 0
bintar.gztar.bz2zipREADME*LICENSE*NOTICE*src/main/binbin*.py*.shunix0755src/main/configconfig*unix0644targetlib*.jarlibjunit:junit
jdynpur-1.0/src/main/assembly/src.xml 100644 0 0 1155 10564300702 15036 0 ustar 0 0
srctar.gztar.bz2zipREADME*LICENSE*NOTICE*pom.xmlcheckstyle.xmlsrc
jdynpur-1.0/src/main/bin/analyzerun.sh 100644 0 0 726 10564557552 15206 0 ustar 0 0 # JAVA_HOME
JAVA_HOME=
# JDynPur installation directory
INSTALL=
# Version of program
VERSION=
#========================== No need to edit anything from here =========================
LIBDIR=${INSTALL}/lib
for jar in $( find $LIBDIR -name "*.jar" | sort -r )
do
CLASSPATH=$jar:${CLASSPATH}
done
# remove last ':'
CLASSPATH=${CLASSPATH:0:${#CLASSPATH} - 1}
$JAVA_HOME/bin/java -Xmx1000M -classpath $CLASSPATH org.softevo.jdynpur.eval.PurityTraceAnalyser "$@"
jdynpur-1.0/src/main/bin/tracerun.sh 100644 0 0 734 10564560170 14626 0 ustar 0 0 # JAVA_HOME
JAVA_HOME=
# JDynPur installation directory
INSTALL=
# Version of program
VERSION=
#========================== No need to edit anything from here =========================
LIBDIR=${INSTALL}/lib
for jar in $( find $LIBDIR -name "*.jar" | sort -r )
do
CLASSPATH=$jar:${CLASSPATH}
done
# remove last ':'
CLASSPATH=${CLASSPATH:0:${#CLASSPATH} - 1}
$JAVA_HOME/bin/java -Xmx1000M -Xbootclasspath/a:$CLASSPATH -javaagent:$INSTALL/lib/jdynpur-$VERSION.jar "$@"
jdynpur-1.0/src/main/bin/updatejre.sh 100644 0 0 234 10564300702 14752 0 ustar 0 0 echo "Updating JRE in $1"
cd $1/lib
rm -rf java
cp -r $HOME/projects/asmdynpur/trunk/target/classes/java .
find java -name "*.class" | xargs jar uvf rt.jar
jdynpur-1.0/src/main/java/java/lang/jdynpur/Tracer.java 100644 0 0 22565 10564077775 20324 0 ustar 0 0 /*
*
*/
package java.lang.jdynpur;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* Methods in this class are called by injected code to write trace events.
* This class continously writes a trace of events into file
* trace.out. If a suffix file (a file named
* suffix_* exists, then the suffix of the filename (e.g. file
* name suffix_0 -> suffix = 0 -> file name = trace.out_0) is appended to the
* name of the outputfile.
*
* @author dallmeier
*/
public class Tracer {
/**
* The stream used to write events.
*/
private static DataOutputStream dataOutputStream = null;
/**
* The size for the write buffer.
*/
private static final int BUFFERSIZE = 16777216;
/**
* The base name for the output file.
*/
public static final String OUTPUTFILENAME = "trace.out";
/**
* Constant for object creation event.
*/
public static final short EV_OBJECTCREATION = 1;
/**
* Constant for field write event.
*/
public static final short EV_FIELDWRITE = 2;
/**
* Constant for static field write event.
*/
public static final short EV_STATICFIELDWRITE = 3;
/**
* Constant for start of dynamic method event.
*/
public static final short EV_DYNAMICMETHODSTART = 4;
/**
* Constant for start of static method event.
*/
public static final short EV_STATICMETHODSTART = 5;
/**
* Constant for start of dynamic method event.
*/
public static final short EV_DYNAMICMETHODEND = 6;
/**
* Constant for end of static method end event.
*/
public static final short EV_STATICMETHODEND = 7;
/**
* Constant for array creation event.
*/
public static final short EV_ARRAYCREATED = 8;
/**
* Constant for array modification event.
*/
public static final short EV_ARRAYMODIFIED = 9;
/**
* Constant indicating access to a static variable or execution of a static
* method.
*/
public static final int STATIC = -1;
/**
* The suffix appended to the name of the trace output file.
*/
private static String suffix = "";
/**
* Mutex object that protects access to the DataOutputStream
*/
private static Object mutex = null;
/*private static HashMap> threadIdToActiveMethodStackMap = new HashMap>();*/
private static boolean debug = false;
/**
* Static initializer creates the output file and adds a shutdown hook such
* that the class is notified when the vm exits.
*/
static {
String fileName;
// System.out.println("Using up 4 date version of Tracer.");
mutex = new Object();
try {
readSuffix();
if (suffix.length() > 0) {
fileName = OUTPUTFILENAME + "_" + suffix;
} else {
fileName = OUTPUTFILENAME;
}
dataOutputStream = new DataOutputStream(new BufferedOutputStream(
new FileOutputStream(fileName), BUFFERSIZE));
Runtime.getRuntime().addShutdownHook(new Thread(new ShutdownThread()));
} catch (IOException exception) {
System.out.println("Unable to create trace outputStream.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* Tries to find a suffix file and reads the suffix for the trace file name if
* any.
*/
private static void readSuffix() {
File[] children;
String suffixFileName;
children = new File("./").listFiles();
for (int counter = 0; counter < children.length; counter++) {
if (children[counter].getName().startsWith("suffix_")) {
suffixFileName = children[counter].getName();
suffix = suffixFileName.substring(7, suffixFileName.length());
}
}
}
/**
* This method is used to safely write events to the output stream. It is
* thread safe. If anything goes wrong writing to the stream, the vm is
* terminated with error code 5.
*
* @param eventId
* the id of the event to be written
* @param value
* the value of the event
*/
private static void writeEvent(short eventId, int value) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeShort(eventId);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
dataOutputStream.writeInt(value);
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* This method writes events that have 2 parameters.
*
* @param eventId
* the id of the event
* @param value1
* the first value
* @param value2
* the second value
*/
private static void writeEvent(short eventId, int value1, Object object) {
try {
synchronized (mutex) {
if (dataOutputStream != null) {
dataOutputStream.writeShort(eventId);
dataOutputStream.writeInt(System.identityHashCode(Thread
.currentThread()));
dataOutputStream.writeInt(value1);
dataOutputStream.writeInt(System.identityHashCode(object));
dataOutputStream.writeUTF(object.getClass().getName());
}
}
} catch (IOException exception) {
System.out.println("An exception occured writing to the trace.");
exception.printStackTrace(System.out);
System.exit(5);
}
}
/**
* Called whenever a field is written in an object.
*
* @param object
* the modified object
*/
public static void fieldWritten(Object object) {
if (debug) {
System.out.println("Field written.");
}
writeEvent(EV_FIELDWRITE, System.identityHashCode(object));
}
/**
* Called whenever a new object is created. This method is called after the
* constructor call.
*
* @param object
* the object that is created
*/
public static void objectCreated(Object object) {
if (debug) {
System.out.println("Object created.");
}
writeEvent(EV_OBJECTCREATION, System.identityHashCode(object));
}
/**
* Called whenever a dynamic method is started.
*
* @param methodId
* the id of the method that is started
* @param thisObject
* the object the method is invoked on
*/
public static void dynamicMethodStarted(int methodId, Object thisObject) {
if (debug) {
System.out.println("Method started " + methodId);
}
writeEvent(EV_DYNAMICMETHODSTART, methodId, thisObject);
}
/**
* Called whenever a static method is started.
*
* @param methodId
* the id of the method that is started
*/
public static void staticMethodStarted(int methodId) {
if (debug) {
System.out.println("Static method started " + methodId);
}
writeEvent(EV_STATICMETHODSTART, methodId);
}
/**
* Called whenever a dynamic method has just finished execution.
*
* @param methodId
* the id of the method
*/
public static void dynamicMethodEnded(int methodId) {
if (debug) {
System.out.println("Dynamic method ended " + methodId);
}
writeEvent(EV_DYNAMICMETHODEND, methodId);
}
/**
* Called whenever a static method has just finished execution.
*
* @param methodId
* the id of the method
*/
public static void staticMethodEnded(int methodId) {
if (debug) {
System.out.println("Static method ended " + methodId);
}
writeEvent(EV_STATICMETHODEND, methodId);
}
/**
* Called whenever a static field was written.
*/
public static void staticFieldWritten() {
if (debug) {
System.out.println("Static field written.");
}
writeEvent(EV_STATICFIELDWRITE, STATIC);
}
/**
* Called whenever a new array was created.
*
* @param object
* the array created
*/
public static void arrayCreated(Object object) {
if (debug) {
System.out.println("Array created.");
}
writeEvent(EV_ARRAYCREATED, System.identityHashCode(object));
}
/**
* Called whenever an entry in an array is modified.
*
* @param object
* the array that was modified
*/
public static void arrayModified(Object object) {
if (debug) {
System.out.println("Array modified.");
}
writeEvent(EV_ARRAYMODIFIED, System.identityHashCode(object));
}
/**
* This method is called to record creation of multi dimensional arrays. This
* is neccessary because otherwise we don't know about the creation of all
* arrays.
*
* @param array
* the object array, possibly containing more object arrays
* @param depth
* the recursion depth
*/
public static void addArraysRecursively(Object[] array, int depth) {
for (int counter = 0; counter < array.length; counter++) {
arrayCreated(array[counter]);
if (depth > 0) {
addArraysRecursively((Object[]) array[counter], depth - 1);
}
}
}
/**
* Gets the suffix used by the tracer.
*/
public static String getSuffix() {
return suffix;
}
/**
* This class implements the shutdown hook needed to assure that all trace
* information gets written at vm shutdown time.
*
* @author dallmeier
*/
private static class ShutdownThread implements Runnable {
/**
* Flushes the stream and closes it.
*/
public void run() {
// System.out.println("Running shutdown thread version 1");
synchronized (mutex) {
try {
if (dataOutputStream != null) {
dataOutputStream.flush();
dataOutputStream.close();
dataOutputStream = null;
}
} catch (IOException finalizeException) {
System.out
.println("An exception occured finalizing trace output stream.");
finalizeException.printStackTrace(System.out);
}
}
}
}
}
jdynpur-1.0/src/main/java/org/softevo/jdynpur/eval/MethodExecutionDisplayer.java 100644 0 0 20376 10564101523 25377 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* This is a utility class used to analyze execution of specific methods. It
* expects a classname and one or more trace files as input and displays
* recorded events only when the specified method is executed.
*/
public class MethodExecutionDisplayer extends PurityTraceAnalyser {
/**
* The method identifier of the method to be displayed.
*/
protected MethodIdentifier identifier = null;
/**
* The integer identifying the sought method.
*/
protected int soughtMethodId = -1;
/**
* The number of times the method is currently active. This is needed for
* recursive calls.
*/
protected int numberOfRunningMethods = 0;
/**
* Creates a new method execution displayer.
*
* @param fileName
* the name of the trace file to replay
* @param identifierMap
* the identifier map for this trace
* @param identifier
* the identifier of the sought method
*/
public MethodExecutionDisplayer(String fileName, MethodIdentifierMapGenerator identifierMap,
MethodIdentifier identifier) {
super(fileName, identifierMap, null, false);
this.identifier = identifier;
this.soughtMethodId = identifierMap.getIdentifier(identifier);
System.out.println("ID of sought method: " + soughtMethodId);
}
/**
* If the sought method is active, this method outputs an array creation
* message on System.out.
*
* @param objectId
* the identifier for the new array
* @param threadId
* the thread id
*/
protected void handleArrayCreation(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Created array " + objectId);
}
super.handleArrayCreation(objectId, threadId);
}
/**
* If the sought method is active, this method outputs an array modification
* message on System.out.
*
* @param objectId
* the identifier for the modified array
* @param threadId
* the thread id
*/
protected void handleArrayModification(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Modified array " + objectId);
}
super.handleArrayModification(objectId, threadId);
}
/**
* If the sought method is active, this method outputs a field modification
* message on System.out.
*
* @param objectId
* the identifier for the modified field
* @param threadId
* the thread id
*/
protected void handleStaticFieldWrite(int threadId) {
if (isMethodRunning()) {
System.out.println("Wrote static field");
}
super.handleStaticFieldWrite(threadId);
}
/**
* If the sought method is active, this method outputs a field modification
* message on System.out.
*
* @param objectId
* the identifier for the modified field
* @param threadId
* the thread id
*/
protected void handleFieldWrite(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Wrote field of object " + objectId);
}
super.handleFieldWrite(objectId, threadId);
}
/**
* If the sought method is active, this method outputs an object creation
* message on System.out.
*
* @param objectId
* the identifier for the new object
* @param threadId
* the thread id
*/
protected void handleObjectCreation(int objectId, int threadId) {
if (isMethodRunning()) {
System.out.println("Created object " + objectId);
}
super.handleObjectCreation(objectId, threadId);
}
/**
* If the sought method is active, this method outputs a method start message
* on System.out and increases the active method count.
*
* @param methodId
* the identifier for the method
* @param threadId
* the thread id
*/
protected void handleMethodStart(int methodId, int threadId, String className) {
if (isSoughtMethod(methodId)) {
numberOfRunningMethods++;
System.out.println("Starting execution of " + identifier + " (" + numberOfRunningMethods + ")");
} else if (isMethodRunning()) {
System.out.println("Intermediate method start " + identifierMap.getMethodIdentifier(methodId));
}
super.handleMethodStart(methodId, threadId, className);
}
/**
* If a method has ended, this method checks if it's execution had
* side-effects and outputs a message on System.out.
*
* @param methodId
* the identifier for the method
* @param threadId
* the thread id
*/
@SuppressWarnings("unchecked")
protected void handleMethodEnd(int methodId, int threadId, String className) {
HashSet createdObjects;
HashSet modifiedObjects;
HashSet setDifference;
Iterator methodIdIterator;
if (isSoughtMethod(methodId)) {
createdObjects = getCreatedObjectSetStack(threadId).pop();
modifiedObjects = getModifiedObjectSetStack(threadId).peek();
if (!createdObjects.containsAll(modifiedObjects)) {
setDifference = (HashSet) modifiedObjects.clone();
setDifference.removeAll(createdObjects);
System.out.println("Method " + identifierMap.getMethodIdentifier(methodId)
+ " impure because of modifications to the following objects:");
methodIdIterator = setDifference.iterator();
while (methodIdIterator.hasNext()) {
System.out.println(methodIdIterator.next());
}
} else {
System.out.println("Method " + identifierMap.getMethodIdentifier(methodId) + " is pure.");
}
getCreatedObjectSetStack(threadId).push(createdObjects);
numberOfRunningMethods--;
System.out.println("Finished execution of " + identifier + " (" + numberOfRunningMethods + ")");
} else if (isMethodRunning()) {
System.out.println("Intermediate method end " + identifierMap.getMethodIdentifier(methodId));
}
super.handleMethodEnd(methodId, threadId, className);
}
/**
* Checks if the sought method is currently executed in the trace.
*/
protected boolean isMethodRunning() {
return numberOfRunningMethods > 0;
}
/**
* Checks if the identifier is for the sought method.
*
* @param methodId
* the id of the method
*/
protected boolean isSoughtMethod(int methodId) {
if (methodId == soughtMethodId) {
return true;
} else {
return false;
}
}
/**
* This method evaluates command line arguments and replays execution for
* every trace file.
*
* @param args
* command line arguments
*/
public static void main(String[] args) throws IOException {
File[] files;
String suffix;
File identityMapFile;
String[] fileNames;
MethodIdentifierMapGenerator identifierMap;
MethodExecutionDisplayer displayer;
String methodIdentifier;
MethodIdentifier identifier;
methodIdentifier = args[0];
files = new File[args.length - 1];
for (int counter = 0; counter < files.length; counter++) {
files[counter] = new File(args[counter + 1]);
}
fileNames = new String[args.length - 1];
for (int counter = 0; counter < fileNames.length; counter++) {
fileNames[counter] = files[counter].getName();
}
for (int counter = 1; counter < args.length; counter++) {
suffix = fileNames[counter - 1].substring(10, fileNames[counter - 1].length());
identityMapFile = new File(files[counter - 1].getParent() + File.separator + "identity.map_" + suffix);
System.out.println("Using identity map file " + identityMapFile.getAbsolutePath());
if (!identityMapFile.exists()) {
System.out.println("Missing identity map file for trace " + suffix);
} else {
identifierMap = MethodIdentifierMapGenerator.load(identityMapFile.getAbsolutePath());
identifier = MethodIdentifier.parseFromIdentifier(methodIdentifier);
try {
identifierMap.getIdentifier(identifier);
displayer = new MethodExecutionDisplayer(args[counter], identifierMap, identifier);
System.out.println("Analysing trace " + args[counter]);
displayer.analyse(false, false);
} catch (NoSuchElementException methodNotExecutedException) {
System.out.println("Method not executed in trace " + args[counter]);
}
}
}
}
}
jdynpur-1.0/src/main/java/org/softevo/jdynpur/eval/MultiplePurityTraceAnalyser.java 100644 0 0 17610 10564101427 26104 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import org.apache.commons.io.filefilter.PrefixFileFilter;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* This class analyzes several execution traces for the same program and merges
* the results. If a method was impure in at least one trace, then it is
* considered to be impure.
*
* @author dallmeier
*/
public class MultiplePurityTraceAnalyser {
/**
* The name of the trace file to be analyzed.
*/
private String fileName = null;
/**
* The set of pure method identifiers.
*/
private HashMap> pureMethodIdentifiers;
/**
* The set of impure method identifiers.
*/
private HashMap> impureMethodIdentifiers;
/**
* The set of executed method identifiers.
*/
private HashMap> executedMethodIdentifiers;
private HashMap> methodsModifyingThis;
private String resultFileName;
/**
* Creates a new analyzer for all traces in the given directory.
*
* @param fileName
* the name of the directory
*/
public MultiplePurityTraceAnalyser(String fileName, String resultFileName) {
this.fileName = fileName;
this.resultFileName = resultFileName;
}
private HashSet getTypeSet(HashMap> map, MethodIdentifier identifier) {
HashSet result;
result = map.get(identifier);
if (result == null) {
result = new HashSet();
map.put(identifier, result);
}
return result;
}
/**
* Analyzes all trace files in the directory. After this method has finished,
* the results are stored in the classes' HashSet fields. This
* method also outputs some information on System.out
*
* @throws IOException
* if an exception occurs reading a trace.
* @throws TransformerException
* @throws ParserConfigurationException
*/
public void analyse() throws IOException, ParserConfigurationException, TransformerException {
File traceDirectory;
File[] children;
File identityMapFile;
String suffix;
String[] fileNames;
MethodIdentifierMapGenerator identifierMap;
PurityTraceAnalyser purityAnalyser;
Iterator newImpureMethodsIterator, newPureMethodsIterator, pureMethodsIterator, impureMethodsIterator;
MethodIdentifier identifier;
boolean isFirstTrace = true;
HashSet pureTypes, impureTypes;
impureMethodIdentifiers = new HashMap>();
pureMethodIdentifiers = new HashMap>();
executedMethodIdentifiers = new HashMap>();
methodsModifyingThis = new HashMap>();
traceDirectory = new File(fileName);
children = traceDirectory.listFiles((FileFilter) new PrefixFileFilter("trace.out_"));
System.out.println("Found " + children.length + " trace files");
fileNames = new String[children.length];
for (int counter = 0; counter < children.length; counter++) {
fileNames[counter] = children[counter].getName();
}
Arrays.sort(fileNames);
for (int counter = 0; counter < fileNames.length; counter++) {
suffix = fileNames[counter].substring(10, fileNames[counter].length());
identityMapFile = new File(traceDirectory.getAbsolutePath() + File.separator + "identity.map_" + suffix);
if (!identityMapFile.exists()) {
System.out.println("Missing identity map file for trace " + suffix);
} else {
System.out.println("Processing files with suffix " + suffix);
identifierMap = MethodIdentifierMapGenerator.load(identityMapFile.getAbsolutePath());
purityAnalyser = new PurityTraceAnalyser(children[counter].getAbsolutePath(), identifierMap, null, false);
System.out.println("Analysing purity trace " + suffix + ".");
purityAnalyser.analyse(false, false);
System.out.println("Analysis results (Pure/Impure/Executed): ("
+ purityAnalyser.getPureMethodIdentifiers().size() + "/"
+ purityAnalyser.getImpureMethodIdentifiers().size() + "/"
+ purityAnalyser.getExecutedMethodIdentifiers().size() + ")");
executedMethodIdentifiers.putAll(purityAnalyser.getExecutedMethodIdentifiers());
methodsModifyingThis.putAll(purityAnalyser.getThisModifyingMethodIdentifiers());
if (isFirstTrace) {
isFirstTrace = false;
pureMethodIdentifiers.putAll(purityAnalyser.getPureMethodIdentifiers());
impureMethodIdentifiers.putAll(purityAnalyser.getImpureMethodIdentifiers());
} else {
newImpureMethodsIterator = purityAnalyser.getImpureMethodIdentifiers().keySet().iterator();
while (newImpureMethodsIterator.hasNext()) {
identifier = newImpureMethodsIterator.next();
pureTypes = getTypeSet(pureMethodIdentifiers, identifier);
pureTypes.removeAll(purityAnalyser.getImpureMethodIdentifiers().get(identifier));
impureTypes = getTypeSet(impureMethodIdentifiers, identifier);
impureTypes.addAll(purityAnalyser.getImpureMethodIdentifiers().get(identifier));
}
newPureMethodsIterator = purityAnalyser.getPureMethodIdentifiers().keySet().iterator();
while (newPureMethodsIterator.hasNext()) {
identifier = newPureMethodsIterator.next();
if (!impureMethodIdentifiers.containsKey(identifier)) {
pureTypes = getTypeSet(pureMethodIdentifiers, identifier);
pureTypes.addAll(purityAnalyser.getPureMethodIdentifiers().get(identifier));
}
}
}
System.out.println("Number of pure methods after trace " + suffix + ": " + pureMethodIdentifiers.size());
System.out.println("Number of impure methods after trace " + suffix + ": " + impureMethodIdentifiers.size());
System.out
.println("Number of executed methods after trace " + suffix + ": " + executedMethodIdentifiers.size());
}
}
System.out.println();
System.out.println("Pure methods:");
pureMethodsIterator = pureMethodIdentifiers.keySet().iterator();
while (pureMethodsIterator.hasNext()) {
System.out.println(pureMethodsIterator.next());
}
System.out.println("Impure methods:");
impureMethodsIterator = impureMethodIdentifiers.keySet().iterator();
while (impureMethodsIterator.hasNext()) {
System.out.println(impureMethodsIterator.next());
}
writeResults();
}
/**
* This method serializes the results to the file system. Pure methods are
* stored in puremethods.ser, impure methods are stored in
* impuremethods.ser, executed methods are store in
* executedmethods.ser.
* @throws TransformerException
* @throws ParserConfigurationException
* @throws IOException
*/
private void writeResults() throws IOException, ParserConfigurationException, TransformerException {
PurityResults results = new PurityResults(pureMethodIdentifiers, impureMethodIdentifiers,
methodsModifyingThis, executedMethodIdentifiers);
results.saveXML(resultFileName);
}
/**
* Launches analysis of a directory of trace files. It expects the name of the
* trace directory as its only argument.
*
* @param args
* the command line arguments
* @throws TransformerException
* @throws ParserConfigurationException
*/
public static void main(String[] args) throws IOException, ParserConfigurationException, TransformerException {
MultiplePurityTraceAnalyser traceAnalyser;
if (args.length != 1) {
System.out.println("Usage: java org.softevo.jdynpur.MultiplePurityTraceAnalyser ");
} else {
traceAnalyser = new MultiplePurityTraceAnalyser(args[0], args[1]);
traceAnalyser.analyse();
}
}
}
jdynpur-1.0/src/main/java/org/softevo/jdynpur/eval/PurityResults.java 100644 0 0 16107 10564101430 23266 0 ustar 0 0 package org.softevo.jdynpur.eval;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.io.ObjectReaderWriter;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
public class PurityResults {
/**
* The set of methods known to modify the object they were invoked on.
*/
protected HashMap> methodsModifyingThisObject = null;
/**
* The set of MethodIdentifiers known to be pure.
*/
protected HashMap> pureMethodIdentifiers = null;
/**
* The set of MethodIdentifiers known to be impure.
*/
protected HashMap> impureMethodIdentifiers = null;
/**
* The set of executed MethodIdentifiers.
*/
protected HashMap> executedMethodIdentifiers = null;
public PurityResults() {
methodsModifyingThisObject = new HashMap>();
pureMethodIdentifiers = new HashMap>();
impureMethodIdentifiers = new HashMap>();
executedMethodIdentifiers = new HashMap>();
}
public PurityResults(HashMap> pureMethodIdentifiers,
HashMap> impureMethodIdentifiers,
HashMap> methodsModifyingThisObject,
HashMap> executedMethodIdentifiers) {
this();
this.executedMethodIdentifiers.putAll(executedMethodIdentifiers);
this.impureMethodIdentifiers.putAll(impureMethodIdentifiers);
this.methodsModifyingThisObject.putAll(methodsModifyingThisObject);
this.pureMethodIdentifiers.putAll(pureMethodIdentifiers);
}
public HashMap> getExecutedMethodIdentifiers() {
return executedMethodIdentifiers;
}
public HashMap> getImpureMethodIdentifiers() {
return impureMethodIdentifiers;
}
public HashMap> getMethodsModifyingThisObject() {
return methodsModifyingThisObject;
}
public HashMap> getPureMethodIdentifiers() {
return pureMethodIdentifiers;
}
public void saveXML(String fileName) throws IOException, ParserConfigurationException, TransformerException {
Document targetDocument = null;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
DOMImplementation impl = builder.getDOMImplementation();
targetDocument = impl.createDocument(null, "purityresults", null);
Element root = targetDocument.getDocumentElement();
Element executedMethodsElement = targetDocument.createElement("executedmethods");
root.appendChild(executedMethodsElement);
addMethodElements(executedMethodsElement, targetDocument, executedMethodIdentifiers);
Element methodsModifyingThisElement = targetDocument.createElement("methodsmodifyingself");
root.appendChild(methodsModifyingThisElement);
addMethodElements(methodsModifyingThisElement, targetDocument, methodsModifyingThisObject);
Element impureMethodsElement = targetDocument.createElement("impuremethods");
root.appendChild(impureMethodsElement);
addMethodElements(impureMethodsElement, targetDocument, impureMethodIdentifiers);
Element pureMethodsElement = targetDocument.createElement("puremethods");
root.appendChild(pureMethodsElement);
addMethodElements(pureMethodsElement, targetDocument, pureMethodIdentifiers);
StreamResult streamResult = new StreamResult(new FileOutputStream(fileName));
TransformerFactory tf = TransformerFactory.newInstance();
Transformer serializer = tf.newTransformer();
serializer.setOutputProperty(OutputKeys.ENCODING,"ISO-8859-1");
serializer.setOutputProperty(OutputKeys.INDENT,"yes");
DOMSource domSource = new DOMSource(targetDocument);
serializer.transform(domSource, streamResult);
}
protected void addMethodElements(Element parent, Document document,
HashMap> methodIdentifiers) {
for (MethodIdentifier identifier : methodIdentifiers.keySet()) {
Element identifierElement = document.createElement("method");
parent.appendChild(identifierElement);
identifierElement.setAttribute("classname", identifier.getClassName());
identifierElement.setAttribute("methodname", identifier.getMethodName());
identifierElement.setAttribute("signature", identifier.getSignature());
identifierElement.setAttribute("access", Integer.toString(identifier.getAccess()));
HashSet invokedClasses = methodIdentifiers.get(identifier);
for (String className : invokedClasses) {
Element classElement = document.createElement("runtimeclass");
identifierElement.appendChild(classElement);
classElement.setAttribute("classname", className);
}
}
}
public void save(String fileName) throws IOException {
ObjectReaderWriter>> writer;
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(fileName);
writer = new ObjectReaderWriter>>();
writer.write(executedMethodIdentifiers, fileOutputStream);
writer.write(pureMethodIdentifiers, fileOutputStream);
writer.write(impureMethodIdentifiers, fileOutputStream);
writer.write(methodsModifyingThisObject, fileOutputStream);
} finally {
if (fileOutputStream != null) {
try {
fileOutputStream.close();
} catch (IOException finalizeException) {
// ignore exception
}
}
}
}
public static PurityResults read(String fileName) throws IOException {
FileInputStream fileInputStream = null;
ObjectReaderWriter>> reader;
PurityResults result;
reader = new ObjectReaderWriter>>();
result = new PurityResults();
try {
fileInputStream = new FileInputStream(fileName);
result.executedMethodIdentifiers.putAll(reader.read(fileInputStream));
result.pureMethodIdentifiers.putAll(reader.read(fileInputStream));
result.impureMethodIdentifiers.putAll(reader.read(fileInputStream));
result.methodsModifyingThisObject.putAll(reader.read(fileInputStream));
return result;
} finally {
if (fileInputStream != null) {
try {
fileInputStream.close();
} catch (IOException finalizeException) {
// ignore exception
}
}
}
}
}
jdynpur-1.0/src/main/java/org/softevo/jdynpur/eval/PurityTraceAnalyser.java 100644 0 0 51252 10564101423 24364 0 ustar 0 0 /*
*
*/
package org.softevo.jdynpur.eval;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Stack;
import java.util.Vector;
import java.lang.jdynpur.Tracer;
import org.softevo.util.asm.MethodIdentifier;
import org.softevo.util.asm.MethodIdentifierMapGenerator;
/**
* This class implements dynamic purity analysis of an execution trace file. The
* main idea of the analysis is as follows:
*
*
For every method, calculate the set of modified and the set of created
* objects.
*
At the end of each method, add the set of created objects to the created
* objects of the calling method.
*
At the end of each method, check wether any object not created during
* the execution of the method was modified. If this is the case, the execution
* was impure, otherwise pure.
*