X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.tmf.core%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Finternal%2Ftmf%2Fcore%2Fstatesystem%2FStateSystem.java;h=ecba187de8ab85d725a11b22d290780690cefc59;hb=1cf2531114f2ff545e67a9450dfa7243fb5dacdd;hp=527f7eee64f222f6aa384c81fd72b8caad122688;hpb=1a4205d9d4a18691a4539ab5479dfbdbd5a3645c;p=deliverable%2Ftracecompass.git diff --git a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/StateSystem.java b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/StateSystem.java index 527f7eee64..ecba187de8 100644 --- a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/StateSystem.java +++ b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/StateSystem.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2012 Ericsson + * Copyright (c) 2012, 2013 Ericsson * Copyright (c) 2010, 2011 École Polytechnique de Montréal * Copyright (c) 2010, 2011 Alexandre Montplaisir * @@ -19,17 +19,22 @@ import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.linuxtools.internal.tmf.core.Activator; +import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend; import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException; +import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException; import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException; import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException; import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval; import org.eclipse.linuxtools.tmf.core.interval.TmfStateInterval; import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystemBuilder; import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue; +import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue.Type; import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue; /** @@ -56,19 +61,33 @@ public class StateSystem implements ITmfStateSystemBuilder { private final CountDownLatch finishedLatch = new CountDownLatch(1); private boolean buildCancelled = false; + private boolean isDisposed = false; + + /** + * New-file constructor. For when you build a state system with a new file, + * or if the back-end does not require a file on disk. + * + * @param backend + * Back-end plugin to use + */ + public StateSystem(@NonNull IStateHistoryBackend backend) { + this.backend = backend; + this.transState = new TransientState(backend); + this.attributeTree = new AttributeTree(this); + } /** * General constructor * * @param backend - * The "state history storage" backend to use. + * The "state history storage" back-end to use. * @param newFile * Put true if this is a new history started from scratch. It is * used to tell the state system where to get its attribute tree. * @throws IOException * If there was a problem creating the new history file */ - public StateSystem(IStateHistoryBackend backend, boolean newFile) + public StateSystem(@NonNull IStateHistoryBackend backend, boolean newFile) throws IOException { this.backend = backend; this.transState = new TransientState(backend); @@ -84,17 +103,33 @@ public class StateSystem implements ITmfStateSystemBuilder { } @Override - public boolean waitUntilBuilt() { + public boolean isCancelled() { + return buildCancelled; + } + + @Override + public void waitUntilBuilt() { try { finishedLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } - return !buildCancelled; + } + + @Override + public boolean waitUntilBuilt(long timeout) { + boolean ret = false; + try { + ret = finishedLatch.await(timeout, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return ret; } @Override public synchronized void dispose() { + isDisposed = true; if (transState.isActive()) { transState.setInactive(); buildCancelled = true; @@ -106,32 +141,39 @@ public class StateSystem implements ITmfStateSystemBuilder { // General methods related to the attribute tree //-------------------------------------------------------------------------- + /** + * Get the attribute tree associated with this state system. This should be + * the only way of accessing it (and if subclasses want to point to a + * different attribute tree than their own, they should only need to + * override this). + * + * @return The attribute tree + */ + public AttributeTree getAttributeTree() { + return attributeTree; + } + /** * Method used by the attribute tree when creating new attributes, to keep * the attribute count in the transient state in sync. */ - void addEmptyAttribute() { + protected void addEmptyAttribute() { transState.addEmptyEntry(); } @Override public int getNbAttributes() { - return attributeTree.getNbAttributes(); - } - - @Override - public boolean isLastAttribute(int quark) { - return (quark == getNbAttributes() - 1) ? true : false; + return getAttributeTree().getNbAttributes(); } @Override public String getAttributeName(int attributeQuark) { - return attributeTree.getAttributeName(attributeQuark); + return getAttributeTree().getAttributeName(attributeQuark); } @Override public String getFullAttributePath(int attributeQuark) { - return attributeTree.getFullAttributeName(attributeQuark); + return getAttributeTree().getFullAttributeName(attributeQuark); } //-------------------------------------------------------------------------- @@ -171,7 +213,7 @@ public class StateSystem implements ITmfStateSystemBuilder { * If null was returned, we simply won't save the attribute tree, * too bad! */ - attributeTree.writeSelf(attributeTreeFile, attributeTreeFilePos); + getAttributeTree().writeSelf(attributeTreeFile, attributeTreeFilePos); } finishedLatch.countDown(); /* Mark the history as finished building */ } @@ -183,36 +225,36 @@ public class StateSystem implements ITmfStateSystemBuilder { @Override public int getQuarkAbsolute(String... attribute) throws AttributeNotFoundException { - return attributeTree.getQuarkDontAdd(-1, attribute); + return getAttributeTree().getQuarkDontAdd(-1, attribute); } @Override public int getQuarkAbsoluteAndAdd(String... attribute) { - return attributeTree.getQuarkAndAdd(-1, attribute); + return getAttributeTree().getQuarkAndAdd(-1, attribute); } @Override public int getQuarkRelative(int startingNodeQuark, String... subPath) throws AttributeNotFoundException { - return attributeTree.getQuarkDontAdd(startingNodeQuark, subPath); + return getAttributeTree().getQuarkDontAdd(startingNodeQuark, subPath); } @Override public int getQuarkRelativeAndAdd(int startingNodeQuark, String... subPath) { - return attributeTree.getQuarkAndAdd(startingNodeQuark, subPath); + return getAttributeTree().getQuarkAndAdd(startingNodeQuark, subPath); } @Override public List getSubAttributes(int quark, boolean recursive) throws AttributeNotFoundException { - return attributeTree.getSubAttributes(quark, recursive); + return getAttributeTree().getSubAttributes(quark, recursive); } @Override public List getQuarks(String... pattern) { - List quarks = new LinkedList(); - List prefix = new LinkedList(); - List suffix = new LinkedList(); + List quarks = new LinkedList<>(); + List prefix = new LinkedList<>(); + List suffix = new LinkedList<>(); boolean split = false; String[] prefixStr; String[] suffixStr; @@ -247,7 +289,7 @@ public class StateSystem implements ITmfStateSystemBuilder { * If there was no wildcard, we'll only return the one matching * attribute, if there is one. */ - if (split == false) { + if (!split) { int quark; try { quark = getQuarkAbsolute(prefixStr); @@ -269,8 +311,7 @@ public class StateSystem implements ITmfStateSystemBuilder { } else { startingAttribute = getQuarkAbsolute(prefixStr); } - directChildren = attributeTree.getSubAttributes(startingAttribute, - false); + directChildren = getSubAttributes(startingAttribute, false); } catch (AttributeNotFoundException e) { /* That attribute path did not exist, return the empty array */ return quarks; @@ -308,10 +349,11 @@ public class StateSystem implements ITmfStateSystemBuilder { public void incrementAttribute(long t, int attributeQuark) throws StateValueTypeException, TimeRangeException, AttributeNotFoundException { - int prevValue = queryOngoingState(attributeQuark).unboxInt(); - if (prevValue == -1) { - /* if the attribute was previously null, start counting at 0 */ - prevValue = 0; + ITmfStateValue stateValue = queryOngoingState(attributeQuark); + int prevValue = 0; + /* if the attribute was previously null, start counting at 0 */ + if (!stateValue.isNull()) { + prevValue = stateValue.unboxInt(); } modifyAttribute(t, TmfStateValue.newValueInt(prevValue + 1), attributeQuark); @@ -321,7 +363,7 @@ public class StateSystem implements ITmfStateSystemBuilder { public void pushAttribute(long t, ITmfStateValue value, int attributeQuark) throws TimeRangeException, AttributeNotFoundException, StateValueTypeException { - Integer stackDepth = 0; + Integer stackDepth; int subAttributeQuark; ITmfStateValue previousSV = transState.getOngoingStateValue(attributeQuark); @@ -330,7 +372,8 @@ public class StateSystem implements ITmfStateSystemBuilder { * If the StateValue was null, this means this is the first time we * use this attribute. Leave stackDepth at 0. */ - } else if (previousSV.getType() == 0) { + stackDepth = 0; + } else if (previousSV.getType() == Type.INTEGER) { /* Previous value was an integer, all is good, use it */ stackDepth = previousSV.unboxInt(); } else { @@ -338,9 +381,9 @@ public class StateSystem implements ITmfStateSystemBuilder { throw new StateValueTypeException(); } - if (stackDepth >= 10) { + if (stackDepth >= 100000) { /* - * Limit stackDepth to 10, to avoid having Attribute Trees grow out + * Limit stackDepth to 100000, to avoid having Attribute Trees grow out * of control due to buggy insertions */ String message = "Stack limit reached, not pushing"; //$NON-NLS-1$ @@ -370,10 +413,10 @@ public class StateSystem implements ITmfStateSystemBuilder { */ return null; } - if (previousSV.getType() != ITmfStateValue.TYPE_INTEGER) { + if (previousSV.getType() != Type.INTEGER) { /* - * The existing value was a string, this doesn't look like a valid - * stack attribute. + * The existing value was not an integer (which is expected for + * stack tops), this doesn't look like a valid stack attribute. */ throw new StateValueTypeException(); } @@ -382,9 +425,8 @@ public class StateSystem implements ITmfStateSystemBuilder { if (stackDepth <= 0) { /* This on the other hand should not happen... */ - /* the case where == -1 was handled previously by .isNull() */ String message = "A top-level stack attribute cannot " + //$NON-NLS-1$ - "have a value of 0 or less (except -1/null)."; //$NON-NLS-1$ + "have a value of 0 or less."; //$NON-NLS-1$ throw new StateValueTypeException(message); } @@ -395,7 +437,7 @@ public class StateSystem implements ITmfStateSystemBuilder { /* Update the state value of the stack-attribute */ ITmfStateValue nextSV; if (--stackDepth == 0 ) { - /* Jump over "0" and store -1 (a null state value) */ + /* Store a null state value */ nextSV = TmfStateValue.nullValue(); } else { nextSV = TmfStateValue.newValueInt(stackDepth); @@ -418,7 +460,7 @@ public class StateSystem implements ITmfStateSystemBuilder { * "Nullify our children first, recursively. We pass 'false' because we * handle the recursion ourselves. */ - childAttributes = attributeTree.getSubAttributes(attributeQuark, false); + childAttributes = getSubAttributes(attributeQuark, false); for (Integer childNodeQuark : childAttributes) { assert (attributeQuark != childNodeQuark); removeAttribute(t, childNodeQuark); @@ -432,7 +474,7 @@ public class StateSystem implements ITmfStateSystemBuilder { * Will not happen since we're inserting null values only, but poor * compiler has no way of knowing this... */ - e.printStackTrace(); + throw new IllegalStateException(e); } } @@ -446,13 +488,29 @@ public class StateSystem implements ITmfStateSystemBuilder { return transState.getOngoingStateValue(attributeQuark); } + @Override + public long getOngoingStartTime(int attribute) + throws AttributeNotFoundException { + return transState.getOngoingStartTime(attribute); + } + @Override public void updateOngoingState(ITmfStateValue newValue, int attributeQuark) throws AttributeNotFoundException { transState.changeOngoingStateValue(attributeQuark, newValue); } - + /** + * Modify the whole "ongoing state" (state values + start times). This can + * be used when "seeking" a state system to a different point in the trace + * (and restoring the known stateInfo at this location). Use with care! + * + * @param newStateIntervals + * The new List of state values to use as ongoing state info + */ + protected void replaceOngoingState(List newStateIntervals) { + transState.replaceOngoingState(newStateIntervals); + } //-------------------------------------------------------------------------- // Regular query methods (sent to the back-end) @@ -460,12 +518,15 @@ public class StateSystem implements ITmfStateSystemBuilder { @Override public synchronized List queryFullState(long t) - throws TimeRangeException { - List stateInfo = new ArrayList( - attributeTree.getNbAttributes()); + throws TimeRangeException, StateSystemDisposedException { + if (isDisposed) { + throw new StateSystemDisposedException(); + } + + List stateInfo = new ArrayList<>(getNbAttributes()); /* Bring the size of the array to the current number of attributes */ - for (int i = 0; i < attributeTree.getNbAttributes(); i++) { + for (int i = 0; i < getNbAttributes(); i++) { stateInfo.add(null); } @@ -487,7 +548,6 @@ public class StateSystem implements ITmfStateSystemBuilder { */ for (int i = 0; i < stateInfo.size(); i++) { if (stateInfo.get(i) == null) { - //logMissingInterval(i, t); stateInfo.set(i, new TmfStateInterval(t, t, i, TmfStateValue.nullValue())); } } @@ -496,12 +556,18 @@ public class StateSystem implements ITmfStateSystemBuilder { @Override public ITmfStateInterval querySingleState(long t, int attributeQuark) - throws AttributeNotFoundException, TimeRangeException { - ITmfStateInterval ret; + throws AttributeNotFoundException, TimeRangeException, + StateSystemDisposedException { + if (isDisposed) { + throw new StateSystemDisposedException(); + } - if (transState.hasInfoAboutStateOf(t, attributeQuark)) { - ret = transState.getOngoingInterval(attributeQuark); - } else { + ITmfStateInterval ret = transState.getIntervalAt(t, attributeQuark); + if (ret == null) { + /* + * The transient state did not have the information, let's look into + * the backend next. + */ ret = backend.doSingularQuery(t, attributeQuark); } @@ -510,7 +576,6 @@ public class StateSystem implements ITmfStateSystemBuilder { * We do NOT want to return 'null' here. */ if (ret == null) { - //logMissingInterval(attributeQuark, t); return new TmfStateInterval(t, this.getCurrentEndTime(), attributeQuark, TmfStateValue.nullValue()); } @@ -520,13 +585,15 @@ public class StateSystem implements ITmfStateSystemBuilder { @Override public ITmfStateInterval querySingleStackTop(long t, int stackAttributeQuark) throws StateValueTypeException, AttributeNotFoundException, - TimeRangeException { - Integer curStackDepth = querySingleState(t, stackAttributeQuark).getStateValue().unboxInt(); + TimeRangeException, StateSystemDisposedException { + ITmfStateValue curStackStateValue = querySingleState(t, stackAttributeQuark).getStateValue(); - if (curStackDepth == -1) { + if (curStackStateValue.isNull()) { /* There is nothing stored in this stack at this moment */ return null; - } else if (curStackDepth < -1 || curStackDepth == 0) { + } + Integer curStackDepth = curStackStateValue.unboxInt(); + if (curStackDepth <= 0) { /* * This attribute is an integer attribute, but it doesn't seem like * it's used as a stack-attribute... @@ -535,20 +602,23 @@ public class StateSystem implements ITmfStateSystemBuilder { } int subAttribQuark = getQuarkRelative(stackAttributeQuark, curStackDepth.toString()); - ITmfStateInterval ret = querySingleState(t, subAttribQuark); - return ret; + return querySingleState(t, subAttribQuark); } @Override public List queryHistoryRange(int attributeQuark, long t1, long t2) throws TimeRangeException, - AttributeNotFoundException { + AttributeNotFoundException, StateSystemDisposedException { + if (isDisposed) { + throw new StateSystemDisposedException(); + } + List intervals; ITmfStateInterval currentInterval; long ts, tEnd; /* Make sure the time range makes sense */ - if (t2 <= t1) { + if (t2 < t1) { throw new TimeRangeException(); } @@ -560,7 +630,7 @@ public class StateSystem implements ITmfStateSystemBuilder { } /* Get the initial state at time T1 */ - intervals = new ArrayList(); + intervals = new ArrayList<>(); currentInterval = querySingleState(t1, attributeQuark); intervals.add(currentInterval); @@ -578,13 +648,19 @@ public class StateSystem implements ITmfStateSystemBuilder { @Override public List queryHistoryRange(int attributeQuark, long t1, long t2, long resolution, IProgressMonitor monitor) - throws TimeRangeException, AttributeNotFoundException { + throws TimeRangeException, AttributeNotFoundException, + StateSystemDisposedException { + if (isDisposed) { + throw new StateSystemDisposedException(); + } + List intervals; ITmfStateInterval currentInterval; long ts, tEnd; - if (monitor == null) { - monitor = new NullProgressMonitor(); + IProgressMonitor mon = monitor; + if (mon == null) { + mon = new NullProgressMonitor(); } /* Make sure the time range makes sense */ @@ -600,7 +676,7 @@ public class StateSystem implements ITmfStateSystemBuilder { } /* Get the initial state at time T1 */ - intervals = new ArrayList(); + intervals = new ArrayList<>(); currentInterval = querySingleState(t1, attributeQuark); intervals.add(currentInterval); @@ -610,7 +686,7 @@ public class StateSystem implements ITmfStateSystemBuilder { */ for (ts = t1; (currentInterval.getEndTime() != -1) && (ts < tEnd); ts += resolution) { - if (monitor.isCanceled()) { + if (mon.isCanceled()) { return intervals; } if (ts <= currentInterval.getEndTime()) { @@ -645,7 +721,7 @@ public class StateSystem implements ITmfStateSystemBuilder { * The PrintWriter in which to print the output */ public void debugPrint(PrintWriter writer) { - attributeTree.debugPrint(writer); + getAttributeTree().debugPrint(writer); transState.debugPrint(writer); backend.debugPrint(writer); }