checkpoint1 = new TmfCheckpoint(fTimestamp1, null);
checkpoint2 = checkpoint1.clone();
assertEquals("clone", checkpoint1, checkpoint2);
- assertNull(checkpoint1.getLocation());
- assertNull(checkpoint2.getLocation());
+ assertNull(checkpoint1.getContext());
+ assertNull(checkpoint2.getContext());
checkpoint1 = new TmfCheckpoint(null, new TmfContext(fLocation1));
checkpoint3 = checkpoint1.clone();
// ------------------------------------------------------------------------
private final TmfTimestamp fTimestamp;
- private final TmfContext[] fContexts;
+ private final long[] fRanks;
// ------------------------------------------------------------------------
// Constructors
*/
public TmfExperimentCheckpoint(TmfTimestamp ts, TmfContext[] contexts) {
fTimestamp = ts;
- fContexts = contexts;
+ fRanks = new long[contexts.length];
+ for (int i = 0; i < fRanks.length; i++) {
+ fRanks[i] = contexts[i].getRank();
+ }
}
// ------------------------------------------------------------------------
}
/**
- * @return the checkpoint event stream location
+ * @return the checkpoint event rank
*/
- public TmfContext[] getContexts() {
- return fContexts;
+ public long[] getRanks() {
+ return fRanks;
}
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
+ /**
+ * @param contexts
+ */
public TmfExperimentContext(final ITmfContext[] contexts) {
super();
fContexts = contexts;
fLastTraceRead = NO_TRACE;
}
+ /**
+ * @param other
+ */
public TmfExperimentContext(final TmfExperimentContext other) {
this(other.cloneContexts());
fEvents = other.fEvents;
setLastTrace(other.fLastTraceRead);
}
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.trace.TmfContext#clone()
+ */
+ @Override
+ public TmfExperimentContext clone() {
+ TmfExperimentContext clone = null;
+ clone = (TmfExperimentContext) super.clone();
+ clone.fContexts = cloneContexts();
+ clone.fEvents = cloneEvents();
+ clone.fLastTraceRead = fLastTraceRead;
+ return clone;
+ }
+
private ITmfContext[] cloneContexts() {
final ITmfContext[] contexts = new ITmfContext[fContexts.length];
for (int i = 0; i < fContexts.length; i++)
- contexts[i] = fContexts[i].clone();
+ contexts[i] = (fContexts[i] != null) ? fContexts[i].clone() : null;
return contexts;
}
private ITmfEvent[] cloneEvents() {
final ITmfEvent[] events = new ITmfEvent[fEvents.length];
for (int i = 0; i < fEvents.length; i++)
- events[i] = fEvents[i].clone();
+ events[i] = (fEvents[i] != null) ? fEvents[i].clone() : null;
return events;
}
- @Override
- public TmfExperimentContext clone2() {
- TmfExperimentContext clone = null;
- clone = (TmfExperimentContext) super.clone();
- clone.fContexts = cloneContexts();
- clone.fEvents = cloneEvents();
- clone.fLastTraceRead = NO_TRACE;
- return clone;
- }
-
// ------------------------------------------------------------------------
// Accessors
// ------------------------------------------------------------------------
if (Tracer.isRequestTraced())
Tracer.traceRequest(request, "read first event"); //$NON-NLS-1$
while (data != null && !isCompleted(request, data, nbRead)) {
-// if (fLogData)
-// Tracer.traceEvent(provider, request, data);
+ if (fLogData) {
+ Tracer.traceEvent(provider, request, data);
+ }
if (request.getDataType().isInstance(data)) {
request.handleData(data);
}
@Override
public CtfIterator clone() {
CtfIterator clone = null;
- clone = new CtfIterator(ctfTmfTrace, this.getCurrentEvent()
- .getTimestampValue(), curRank);
+ clone = new CtfIterator(ctfTmfTrace, this.getCurrentEvent().getTimestampValue(), curRank);
return clone;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#clone2()
- */
- @Override
- public CtfIterator clone2() {
- return clone();
- }
-
/**
* Method dispose.
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#dispose()
*/
@Override
public CtfLocation clone() {
- return new CtfLocation(getLocation());
+ return new CtfLocation(getLocation().longValue());
}
/* (non-Javadoc)
public CtfTmfEvent parseEvent(ITmfContext context) {
CtfTmfEvent event = null;
if( context instanceof CtfIterator ){
- CtfIterator itt = (CtfIterator) context;
+ CtfIterator itt = (CtfIterator) context.clone();
event = itt.getCurrentEvent();
}
return event;
public ITmfTimestamp getTimestamp();
/**
- * @return the trace context
+ * @return the location of the event referred to by the context
*/
public ITmfContext getContext();
*/
public ITmfContext clone();
- /**
- * @return a clone of the context
- */
- public ITmfContext clone2();
+// /**
+// * @return a clone of the context
+// */
+// public ITmfContext clone2();
}
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfCheckpoint#getLocation()
*/
@Override
- public ITmfLocation<?> getLocation() {
- return (fContext != null) ? fContext.getLocation() : null;
+ public ITmfContext getContext() {
+ return fContext;
}
/* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfCheckpoint#getContext()
+ * @see org.eclipse.linuxtools.tmf.core.trace.ITmfCheckpoint#getLocation()
*/
- @Override
- public ITmfContext getContext() {
- return fContext;
+ public ITmfLocation<? extends Comparable<?>> getLocation() {
+ return fContext.getLocation();
}
// ------------------------------------------------------------------------
@SuppressWarnings({ "unchecked", "rawtypes" })
public int compareTo(final ITmfCheckpoint other) {
if (fTimestamp == null || other.getTimestamp() == null) {
- final Comparable location1 = fContext.getLocation().getLocation();
+ final Comparable location1 = getLocation().getLocation();
final Comparable location2 = other.getLocation().getLocation();
return location1.compareTo(location2);
}
final long position = rank / fCheckpointInterval;
// Add new entry at proper location (if empty)
if (fTraceIndex.size() == position) {
- fTraceIndex.add(new TmfCheckpoint(timestamp.clone(), context.clone2()));
+ fTraceIndex.add(new TmfCheckpoint(timestamp.clone(), context.clone()));
}
}
}
}
// Position the trace at the checkpoint
- return seekCheckpoint(index);
+ return restoreCheckpoint(index);
}
/* (non-Javadoc)
final int index = (int) rank / fCheckpointInterval;
// Position the trace at the checkpoint
- return seekCheckpoint(index);
+ return restoreCheckpoint(index);
}
/**
* @param checkpoint the checkpoint index
* @return the corresponding context
*/
- private ITmfContext seekCheckpoint(final int checkpoint) {
+ private ITmfContext restoreCheckpoint(final int checkpoint) {
ITmfLocation<?> location = null;
int index = 0;
synchronized (fTraceIndex) {
if (index >= fTraceIndex.size()) {
index = fTraceIndex.size() - 1;
}
- final ITmfContext context = fTraceIndex.get(index).getContext().clone2();
-// fTrace.seekEvent(context.getLocation());
- return context;
+ return fTraceIndex.get(index).getContext().clone();
}
}
final ITmfContext context = fTrace.seekEvent(location);
return clone;
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#clone2()
- */
- @Override
- public TmfContext clone2() {
- return clone();
- }
-
// ------------------------------------------------------------------------
// ITmfContext
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
@Override
- protected ITmfContext armRequest(final ITmfDataRequest<T> request) {
+ protected synchronized ITmfContext armRequest(final ITmfDataRequest<T> request) {
if (request instanceof ITmfEventRequest<?>
&& !TmfTimestamp.BIG_BANG.equals(((ITmfEventRequest<T>) request).getRange().getStartTime())
&& request.getIndex() == 0)
// ------------------------------------------------------------------------
/* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#getNext(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
+ * @see org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser#parseEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
*/
@Override
- public synchronized T getNext(final ITmfContext context) {
- final ITmfContext previousContext = context.clone();
- final T event = parseEvent(context);
- if (event != null) {
- updateAttributes(previousContext, event.getTimestamp());
-
- fExperimentContext = (TmfExperimentContext) context;
- int trace = fExperimentContext.getLastTrace();
- if (trace != TmfExperimentContext.NO_TRACE) {
- TmfExperimentLocation location = (TmfExperimentLocation) fExperimentContext.getLocation();
- location.getLocation().getLocations()[trace] = fExperimentContext.getContexts()[trace].getLocation();
- }
-
- context.increaseRank();
- processEvent(event);
- }
+ public synchronized T parseEvent(final ITmfContext context) {
+ final ITmfContext savedContext = context.clone();
+ final T event = getNext(savedContext);
return event;
}
/* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser#parseEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
+ * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#getNext(org.eclipse.linuxtools.tmf.core.trace.ITmfContext)
*/
@SuppressWarnings("unchecked")
@Override
- public T parseEvent(ITmfContext context) {
+ public synchronized T getNext(ITmfContext context) {
// Validate the context
if (!(context instanceof TmfExperimentContext)) {
return null; // Throw an exception?
}
-
TmfExperimentContext expContext = (TmfExperimentContext) context;
// If an event was consumed previously, first get the next one from that trace
T event = null;
if (trace != TmfExperimentContext.NO_TRACE) {
event = (T) expContext.getEvents()[trace];
+ if (event != null) {
+ updateAttributes(expContext, event.getTimestamp());
+ TmfExperimentLocation location = (TmfExperimentLocation) expContext.getLocation();
+ location.getLocation().getLocations()[trace] = expContext.getContexts()[trace].getLocation();
+ expContext.increaseRank();
+ expContext.setLastTrace(trace);
+ fExperimentContext = expContext;
+ processEvent(event);
+ }
}
- expContext.setLastTrace(trace);
return event;
}
event = getNext(context);
}
}
+// System.out.println("seekEvent() before parseEvent() context=" + context);
+// ITmfEvent event = fParser.parseEvent(context);
+// System.out.println("seekEvent() after parseEvent() context=" + context + " TS=" + event.getTimestamp());
+// event = fParser.parseEvent(context);
+// System.out.println("seekEvent() after parseEvent() context=" + context + " TS=" + event.getTimestamp());
return context;
}
}
// Position the trace at the checkpoint
- final ITmfContext context = fIndexer.seekIndex(timestamp);
+ ITmfContext context = fIndexer.seekIndex(timestamp);
// And locate the requested event context
final ITmfContext nextEventContext = context.clone(); // Must use clone() to get the right subtype...
ITmfEvent event = getNext(nextEventContext);
while (event != null && event.getTimestamp().compareTo(timestamp, false) < 0) {
- context.setLocation(nextEventContext.getLocation().clone());
- context.increaseRank();
+ context = nextEventContext.clone();
event = getNext(nextEventContext);
}
if (event == null) {
projects / deliverable / tracecompass.git / commitdiff
