diff --git a/org.ntlab.traceAnalyzer/src/org/ntlab/trace/MethodExecution.java b/org.ntlab.traceAnalyzer/src/org/ntlab/trace/MethodExecution.java index 3a9387c..9c8e402 100644 --- a/org.ntlab.traceAnalyzer/src/org/ntlab/trace/MethodExecution.java +++ b/org.ntlab.traceAnalyzer/src/org/ntlab/trace/MethodExecution.java @@ -260,4 +260,29 @@ public void setAugmentation(AugmentationInfo augmentation) { this.augmentation = augmentation; } + + /** + *�@�����œn���ꂽmethodExecution���Ăяo�������\�b�h�Ăяo����T���ĕԂ� + * @param child ����methodExecution����Ăяo���ꂽ���Ƃ̂���ʂ�methodExecution + * @return �����œn���ꂽmethodExecution���Ăяo�������Ƃ��L�^���Ă��郁�\�b�h�Ăяo�� + */ + public MethodInvocation getMethodInvocation(MethodExecution child) { + int callerStatementExecution = child.getCallerStatementExecution(); + if (callerStatementExecution != -1) { + return (MethodInvocation)statements.get(callerStatementExecution); + } + return null; + } + + /** + * order���w�肵�đΉ�����TracePoint��Ԃ� + * @param order TracePoint��order + * @return + */ + public TracePoint getTracePoint(int order) { + if (order < this.getStatements().size()) { + return new TracePoint(this, order); + } + return null; + } } diff --git a/org.ntlab.traceAnalyzer/src/org/ntlab/trace/Trace.java b/org.ntlab.traceAnalyzer/src/org/ntlab/trace/Trace.java index 47c4f44..ae2e659 100644 --- a/org.ntlab.traceAnalyzer/src/org/ntlab/trace/Trace.java +++ b/org.ntlab.traceAnalyzer/src/org/ntlab/trace/Trace.java @@ -11,9 +11,9 @@ public class Trace { protected static final boolean EAGER_DETECTION_OF_ARRAY_SET = false; // �z��v�f�ւ̑���̌��o�𑽂����ς��邩?(�������ς����False Positive�ɂȂ�”\��������) - + protected static Trace theTrace = null; protected HashMap threads = new HashMap(); - + protected Trace() { } @@ -44,6 +44,13 @@ e.printStackTrace(); } } + + public static Trace getInstance() { + if (theTrace == null) { + theTrace = new Trace(); + } + return theTrace; + } private void read(BufferedReader file) throws IOException { // �g���[�X�t�@�C���ǂݍ��� @@ -177,8 +184,8 @@ * @param thread �ΏۃX���b�h * @return thread ��Ō��ݎ��s���̃��\�b�h���s */ - public MethodExecution getCurrentMethodExecution(Thread thread) { - ThreadInstance t = threads.get(thread.getId()); + public static MethodExecution getCurrentMethodExecution(Thread thread) { + ThreadInstance t = getInstance().threads.get(String.valueOf(thread.getId())); return t.getCurrentMethodExecution(); } @@ -187,8 +194,8 @@ * @param thread �ΏۃX���b�h * @return thread ��Ō��ݎ��s���̎��s���̃g���[�X�|�C���g */ - public TracePoint getCurrentTracePoint(Thread thread) { - ThreadInstance t = threads.get(thread.getId()); + public static TracePoint getCurrentTracePoint(Thread thread) { + ThreadInstance t = getInstance().threads.get(String.valueOf(thread.getId())); return t.getCurrentTracePoint(); } @@ -739,6 +746,12 @@ return traverseStatementsInTraceBackwardSub(visitor, threadRoots, threadLastPoints, traceLastThread, traceLastThread2, traceLastTime2); } + /** + * + * @param visitor + * @param before + * @return + */ public TracePoint traverseStatementsInTraceBackward(IStatementVisitor visitor, TracePoint before) { if (traverseStatamentsInCallTreeBackwardNoReturn(visitor, before)) return before; HashMap> threadRoots = new HashMap>(); @@ -853,6 +866,13 @@ return getLastMethodEntryInThread(rootExecutions, start, -1L); } + /** + * + * @param rootExecutions + * @param start + * @param before + * @return + */ private TracePoint getLastMethodEntryInThread(ArrayList rootExecutions, TracePoint start, final long before) { final TracePoint cp[] = new TracePoint[1]; cp[0] = start; diff --git a/org.ntlab.traceAnalyzer/src/org/ntlab/trace/TraceJSON.java b/org.ntlab.traceAnalyzer/src/org/ntlab/trace/TraceJSON.java index 5d5548c..bc8ed4a 100644 --- a/org.ntlab.traceAnalyzer/src/org/ntlab/trace/TraceJSON.java +++ b/org.ntlab.traceAnalyzer/src/org/ntlab/trace/TraceJSON.java @@ -4,14 +4,23 @@ import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; import java.util.Stack; public class TraceJSON extends Trace { private HashMap classes = new HashMap<>(); + private HashMap> stacks = new HashMap>(); + private TraceJSON() { + + } + /** * �w�肵��JSON�̃g���[�X�t�@�C������ǂ��� Trace �I�u�W�F�N�g�𐶐����� * @param file �g���[�X�t�@�C�� @@ -39,6 +48,13 @@ e.printStackTrace(); } } + + public static TraceJSON getInstance() { + if (theTrace == null) { + theTrace = new TraceJSON(); + } + return (TraceJSON)theTrace; + } private void readJSON(BufferedReader file) throws IOException { // �g���[�X�t�@�C���ǂݍ��� @@ -402,13 +418,13 @@ } return argumentsData; } - - public void initializeClass(String name, String path, String loaderPath) { - classes.put(name, new ClassInfo(name, path, loaderPath)); + + public static void initializeClass(String name, String path, String loaderPath) { + getInstance().classes.put(name, new ClassInfo(name, path, loaderPath)); } - - public ClassInfo getClassInfo(String className) { - return classes.get(className); + + public static ClassInfo getClassInfo(String className) { + return getInstance().classes.get(className); } public TracePoint getArraySetTracePoint(final Reference ref, TracePoint before) { @@ -622,4 +638,148 @@ } return flows; } -} + + public static HashMap getClasses() { + return getInstance().classes; + } + + public static HashMap getThreads() { + return getInstance().threads; + } + + public static HashMap> getStacks() { + return getInstance().stacks; + } + + public static ThreadInstance getThreadInstance(String threadId) { + return getInstance().threads.get(threadId); + } + + /** + * �w�肵���X���b�h��Ō��ݎ��s���̃��\�b�h���s���擾���� + * @param thread �ΏۃX���b�h + * @return thread ��Ō��ݎ��s���̃��\�b�h���s + */ + public static MethodExecution getCurrentMethodExecution(Thread thread) { + ThreadInstance t = getInstance().threads.get(String.valueOf(thread.getId())); + return t.getCurrentMethodExecution(); + } + + /** + * �w�肵���X���b�h��Ō��ݎ��s���̃g���[�X�|�C���g���擾���� + * @param thread �ΏۃX���b�h + * @return thread ��Ō��ݎ��s���̎��s���̃g���[�X�|�C���g + */ + public static TracePoint getCurrentTracePoint(Thread thread) { + ThreadInstance t = getInstance().threads.get(String.valueOf(thread.getId())); + return t.getCurrentTracePoint(); + } + + /** + * �����œn�����R���e�i�����ƒt�B�[���h�̍ŏI�X�V�ɑΉ�����FieldUpdate��Ԃ� + * @param containerObjId + * @param fieldName + * @param thread + * @return + */ + public static FieldUpdate getRecentlyFieldUpdate(String containerObjId, String fieldName, Thread thread) { + TracePoint before = getCurrentTracePoint(thread); + if (!before.isValid()) { + before.stepBackOver(); + if (!before.isValid()) { + return null; // �t�����T���ł���ȏ�H��Ȃ������ꍇ(root���\�b�h���s��1�s�ڂȂ�)�@���ꂪ�Ȃ��Ǝ��s����TimeoutException�ŗ����� + } + } + TracePoint tp = getFieldUpdateTracePoint(containerObjId, fieldName, before); + if (tp != null && tp.getStatement() instanceof FieldUpdate) { + return (FieldUpdate)tp.getStatement(); + } + return null; + } + + /** + * �����Ŏw�肵���R���e�i�̎��“���̃t�B�[���h���Ō�ɍX�V���ꂽstatement���t�����ɒT�����āA
+ * ���‚�����statement�ɑΉ�����TracePoint��Ԃ� + * @param containerObjId + * @param fieldName + * @param before + * @return + */ + public static TracePoint getFieldUpdateTracePoint(final String containerObjId, final String fieldName, TracePoint before) { + before = before.duplicate(); + before = getInstance().traverseStatementsInTraceBackward(new IStatementVisitor() { + @Override + public boolean preVisitStatement(Statement statement) { + if (statement instanceof FieldUpdate) { + FieldUpdate fu = (FieldUpdate)statement; + if (fu.getContainerObjId().equals(containerObjId) + && fu.getFieldName().equals(fieldName)) { + // �R���e�i�I�u�W�F�N�gID�ƃt�B�[���h�������Ɉ�v�����ꍇ + return true; + } + } + return false; + } + @Override + public boolean postVisitStatement(Statement statement) { return false; } + }, before); + if (before != null) { + return before; + } + return null; + } + + /** + * �����œn�����z��̎w��C���f�b�N�X�̍ŏI�X�V�ɑΉ�����ArrayUpdate��Ԃ� + * @param arrayObjId + * @param index + * @param thread + * @return + */ + public static ArrayUpdate getRecentlyArrayUpdate(String arrayObjId, int index, Thread thread) { + TracePoint before = getCurrentTracePoint(thread); + if (!before.isValid()) { + before.stepBackOver(); + if (!before.isValid()) { + return null; // �t�����T���ł���ȏ�H��Ȃ������ꍇ(root���\�b�h���s��1�s�ڂȂ�)�@���ꂪ�Ȃ��Ǝ��s����TimeoutException�ŗ����� + } + } + TracePoint tp = getArrayUpdateTracePoint(arrayObjId, index, before); + if (tp != null && tp.getStatement() instanceof ArrayUpdate) { + return (ArrayUpdate)tp.getStatement(); + } + return null; + } + + /** + * �����Ŏw�肵���z��ŁA���Žw�肵���C���f�b�N�X���Ō�ɍX�V���ꂽstatement���t�����ɒT�����āA
+ * ���‚�����statement�ɑΉ�����TracePoint��Ԃ� + * @param arrayObjId + * @param index + * @param before + * @return + */ + public static TracePoint getArrayUpdateTracePoint(final String arrayObjId, final int index, TracePoint before) { + before = before.duplicate(); + before = getInstance().traverseStatementsInTraceBackward(new IStatementVisitor() { + @Override + public boolean preVisitStatement(Statement statement) { + if (statement instanceof ArrayUpdate) { + ArrayUpdate au = (ArrayUpdate)statement; + if (au.getArrayObjectId().equals(arrayObjId) + && au.getIndex() == index) { + // �z��ID�ƃC���f�b�N�X�����Ɉ�v�����ꍇ + return true; + } + } + return false; + } + @Override + public boolean postVisitStatement(Statement statement) { return false; } + }, before); + if (before != null) { + return before; + } + return null; + } +} \ No newline at end of file