/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are made
* available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
- * Contributors: Matthew Khouzam - Initial API and implementation
+ * Contributors:
+ * Matthew Khouzam - Initial API and implementation
+ * Patrick Tasse - Updated for removal of context clone
*******************************************************************************/
-
package org.eclipse.linuxtools.tmf.core.ctfadaptor;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.linuxtools.ctf.core.event.EventDeclaration;
-import org.eclipse.linuxtools.ctf.core.event.EventDefinition;
import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException;
import org.eclipse.linuxtools.ctf.core.trace.CTFTrace;
-import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp.TimestampType;
-import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
-import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier;
+import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
-public class CtfTmfTrace extends TmfTrace<CtfTmfEvent> implements ITmfEventParser<CtfTmfEvent>{
+/**
+ * The CTf trace handler
+ *
+ * @version 1.0
+ * @author Matthew khouzam
+ */
+public class CtfTmfTrace extends TmfTrace implements ITmfEventParser {
+
//-------------------------------------------
// Constants
* Default cache size for CTF traces
*/
protected static final int DEFAULT_CACHE_SIZE = 50000;
-
+
//-------------------------------------------
// Fields
//-------------------------------------------
- /** Reference to the state system assigned to this trace */
- protected IStateSystemQuerier ss = null;
-
/* Reference to the CTF Trace */
private CTFTrace fTrace;
+
+
//-------------------------------------------
// TmfTrace Overrides
//-------------------------------------------
/**
* Method initTrace.
- * @param resource IResource
- * @param path String
- * @param eventType Class<CtfTmfEvent>
+ *
+ * @param resource
+ * The resource associated with this trace
+ * @param path
+ * The path to the trace file
+ * @param eventType
+ * The type of events that will be read from this trace
* @throws TmfTraceException
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#initTrace(IResource, String, Class<CtfTmfEvent>)
+ * If something when wrong while reading the trace
*/
@Override
- public void initTrace(final IResource resource, final String path, final Class<CtfTmfEvent> eventType)
+ public void initTrace(final IResource resource, final String path, final Class<? extends ITmfEvent> eventType)
throws TmfTraceException {
/*
* Set the cache size. This has to be done before the call to super()
* because the super needs to know the cache size.
*/
setCacheSize();
- super.initTrace(resource, path, eventType);
- EventDeclaration ed;
- ITmfEventField eventField;
@SuppressWarnings("unused")
CtfTmfEventType type;
try {
this.fTrace = new CTFTrace(path);
- for( int i =0 ; i< this.fTrace.getNbEventTypes(); i++) {
- ed = this.fTrace.getEventType(i);
- eventField = parseDeclaration(ed);
- /*
- * Populate the event manager with event types that are there in
- * the beginning.
- */
- type = new CtfTmfEventType(ed.getName(), eventField);
- }
-
+ CtfIteratorManager.addTrace(this);
+ CtfTmfContext ctx;
/* Set the start and (current) end times for this trace */
- final CtfIterator iterator = new CtfIterator(this, 0, 0);
- if(iterator.getLocation().equals(CtfIterator.NULL_LOCATION)) {
+ ctx = (CtfTmfContext) seekEvent(0L);
+ CtfTmfEvent event = getNext(ctx);
+ if((ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) || (ctx.getCurrentEvent() == null)) {
/* Handle the case where the trace is empty */
this.setStartTime(TmfTimestamp.BIG_BANG);
} else {
- this.setStartTime(iterator.getCurrentEvent().getTimestamp());
- this.setEndTime(iterator.getCurrentEvent().getTimestamp());
+ final ITmfTimestamp curTime = event.getTimestamp();
+ this.setStartTime(curTime);
+ this.setEndTime(curTime);
}
} catch (final CTFReaderException e) {
throw new TmfTraceException(e.getMessage(), e);
}
- //FIXME This should be called via the ExperimentUpdated signal
- buildStateSystem();
+ super.initTrace(resource, path, eventType);
+ }
- /* Refresh the project, so it can pick up new files that got created. */
- if ( resource != null) {
- try {
- resource.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
- } catch (CoreException e) {
- throw new TmfTraceException(e.getMessage(), e);
- }
+ /* (non-Javadoc)
+ * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#dispose()
+ */
+ @Override
+ public synchronized void dispose() {
+ CtfIteratorManager.removeTrace(this);
+ if (fTrace != null) {
+ fTrace.dispose();
+ fTrace = null;
}
+ super.dispose();
}
/**
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#validate(IProject, String)
*/
@Override
- public boolean validate(@SuppressWarnings("unused") final IProject project, final String path) {
+ public boolean validate(final IProject project, final String path) {
try {
final CTFTrace temp = new CTFTrace(path);
- return temp.majortIsSet(); // random test
+ boolean valid = temp.majortIsSet(); // random test
+ temp.dispose();
+ return valid;
} catch (final CTFReaderException e) {
/* Nope, not a CTF trace we can read */
return false;
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getCurrentLocation()
*/
@Override
- public ITmfLocation<?> getCurrentLocation() {
+ public ITmfLocation getCurrentLocation() {
return null;
}
-
-
@Override
- public double getLocationRatio(ITmfLocation<?> location) {
+ public double getLocationRatio(ITmfLocation location) {
final CtfLocation curLocation = (CtfLocation) location;
- CtfIterator iterator = new CtfIterator(this);
- iterator.seek(curLocation.getLocation());
- return ((double) iterator.getCurrentEvent().getTimestampValue() - iterator
- .getStartTime())
- / (iterator.getEndTime() - iterator.getStartTime());
+ final CtfTmfContext context = new CtfTmfContext(this);
+ context.setLocation(curLocation);
+ context.seek(curLocation.getLocationInfo());
+ final CtfLocationInfo currentTime = ((CtfLocationInfo)context.getLocation().getLocationInfo());
+ final long startTime = getIterator(this, context).getStartTime();
+ final long endTime = getIterator(this, context).getEndTime();
+ return ((double) currentTime.getTimestamp() - startTime)
+ / (endTime - startTime);
}
/**
* Method seekEvent.
* @param location ITmfLocation<?>
* @return ITmfContext
- * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#seekEvent(ITmfLocation<?>)
*/
@Override
- public ITmfContext seekEvent(final ITmfLocation<?> location) {
+ public synchronized ITmfContext seekEvent(final ITmfLocation location) {
CtfLocation currentLocation = (CtfLocation) location;
- CtfIterator context = new CtfIterator(this);
+ CtfTmfContext context = new CtfTmfContext(this);
+ if (fTrace == null) {
+ context.setLocation(null);
+ context.setRank(ITmfContext.UNKNOWN_RANK);
+ return context;
+ }
/*
* The rank is set to 0 if the iterator seeks the beginning. If not, it
* will be set to UNKNOWN_RANK, since CTF traces don't support seeking
* by rank for now.
*/
if (currentLocation == null) {
- currentLocation = new CtfLocation(0L);
+ currentLocation = new CtfLocation(new CtfLocationInfo(0L, 0L));
context.setRank(0);
}
- if (currentLocation.getLocation() == CtfLocation.INVALID_LOCATION) {
- ((CtfTmfTimestamp) getEndTime()).setType(TimestampType.NANOS);
- currentLocation.setLocation(getEndTime().getValue() + 1);
+ if (currentLocation.getLocationInfo() == CtfLocation.INVALID_LOCATION) {
+ currentLocation = new CtfLocation(getEndTime().getValue() + 1, 0L);
}
context.setLocation(currentLocation);
- if(context.getRank() != 0)
- context.setRank(ITmfContext.UNKNOWN_RANK);
+ if (location == null) {
+ CtfTmfEvent event = getIterator(this, context).getCurrentEvent();
+ if (event != null) {
+ currentLocation = new CtfLocation(event.getTimestamp().getValue(), 0);
+ }
+ }
+ if(context.getRank() != 0) {
+ context.setRank(ITmfContext.UNKNOWN_RANK);
+ }
return context;
}
@Override
- public ITmfContext seekEvent(double ratio) {
- CtfIterator context = new CtfIterator(this);
- context.seek((long) (this.getNbEvents() * ratio));
+ public synchronized ITmfContext seekEvent(double ratio) {
+ CtfTmfContext context = new CtfTmfContext(this);
+ if (fTrace == null) {
+ context.setLocation(null);
+ context.setRank(ITmfContext.UNKNOWN_RANK);
+ return context;
+ }
+ final long end = this.getEndTime().getValue();
+ final long start = this.getStartTime().getValue();
+ final long diff = end - start;
+ final long ratioTs = Math.round(diff * ratio) + start;
+ context.seek(ratioTs);
context.setRank(ITmfContext.UNKNOWN_RANK);
return context;
}
*/
@Override
public synchronized CtfTmfEvent getNext(final ITmfContext context) {
+ if (fTrace == null) {
+ return null;
+ }
CtfTmfEvent event = null;
- if (context instanceof CtfIterator) {
- CtfIterator ctfIterator = (CtfIterator) context;
- event = ctfIterator.getCurrentEvent();
+ if (context instanceof CtfTmfContext) {
+ if (context.getLocation() == null || CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationInfo())) {
+ return null;
+ }
+ CtfTmfContext ctfContext = (CtfTmfContext) context;
+ event = ctfContext.getCurrentEvent();
if (event != null) {
updateAttributes(context, event.getTimestamp());
- ctfIterator.advance();
- ctfIterator.increaseRank();
+ ctfContext.advance();
+ ctfContext.increaseRank();
}
}
return event;
}
- /**
- * Suppressing the warning, because the 'throws' will usually happen in
- * sub-classes.
- * @throws TmfTraceException
- */
- @SuppressWarnings({ "static-method", "unused" })
- protected void buildStateSystem() throws TmfTraceException {
- /*
- * Nothing is done in the basic implementation, please specify
- * how/if to build a state system in derived classes.
- */
- return;
- }
-
- /**
- * Method getStateSystem.
- *
- * @return IStateSystemQuerier
- */
- public IStateSystemQuerier getStateSystem() {
- return this.ss;
- }
-
- /**
- *
- * @param ed
- * @return
- */
- private static ITmfEventField parseDeclaration(EventDeclaration ed) {
- EventDefinition eventDef = ed.createDefinition(null);
- return new CtfTmfContent(ITmfEventField.ROOT_FIELD_ID,
- CtfTmfEvent.parseFields(eventDef));
- }
-
/**
* gets the CTFtrace that this is wrapping
* @return the CTF trace
// Clocks
//-------------------------------------------
+ /**
+ * gets the clock offset
+ * @return the clock offset in ns
+ */
public long getOffset(){
if( fTrace != null ) {
return fTrace.getOffset();
@Override
public CtfTmfEvent parseEvent(ITmfContext context) {
CtfTmfEvent event = null;
- if( context instanceof CtfIterator ){
- CtfIterator itt = (CtfIterator) context;
- event = itt.getCurrentEvent();
+ if (context instanceof CtfTmfContext) {
+ final ITmfContext tmpContext = seekEvent(context.getLocation());
+ event = getNext(tmpContext);
}
return event;
}
-
+
/**
- * Sets the cache size for a CtfTmfTrace.
+ * Sets the cache size for a CtfTmfTrace.
*/
protected void setCacheSize() {
setCacheSize(DEFAULT_CACHE_SIZE);
}
+ //-------------------------------------------
+ // Helpers
+ //-------------------------------------------
+
+ private static CtfIterator getIterator(CtfTmfTrace trace, CtfTmfContext context) {
+ return CtfIteratorManager.getIterator(trace, context);
+ }
+
+ /**
+ * Get an iterator to the trace
+ *
+ * @return an iterator to the trace
+ * @since 2.0
+ */
+ public CtfIterator createIterator(){
+ return new CtfIterator(this);
+ }
}
projects / deliverable / tracecompass.git / blobdiff