X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.tmf.core%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Ftmf%2Fcore%2Fctfadaptor%2FCtfTmfTrace.java;h=be3f94d45792899f06e4a2e407a6d41bccbd3b9c;hb=4a1108602318db28683d50e17642d73074a10c1b;hp=3a81bbb0ba68dc0ba038526731f8bdffab8eac9d;hpb=8636b4483adef5bf3b784079665703d7efcd9db7;p=deliverable%2Ftracecompass.git diff --git a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfTrace.java b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfTrace.java index 3a81bbb0ba..be3f94d457 100644 --- a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfTrace.java +++ b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfTrace.java @@ -1,318 +1,331 @@ -package org.eclipse.linuxtools.tmf.core.ctfadaptor; +/******************************************************************************* + * Copyright (c) 2012 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 + *******************************************************************************/ + -import java.io.FileNotFoundException; -import java.util.Vector; +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.component.TmfEventProvider; -import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp; -import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange; +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.request.ITmfDataRequest; -import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest; -import org.eclipse.linuxtools.tmf.core.signal.TmfSignal; -import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager; +import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException; +import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier; 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.ITmfTrace; -import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpoint; - -public class CtfTmfTrace extends TmfEventProvider implements - ITmfTrace { +import org.eclipse.linuxtools.tmf.core.trace.TmfTrace; - // ------------------------------------------------------------------------ - // Constants - // ------------------------------------------------------------------------ +public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ - // The default number of events to cache - // TODO: Make the DEFAULT_CACHE_SIZE a preference - public static final int DEFAULT_INDEX_PAGE_SIZE = 50000; + //------------------------------------------- + // Constants + //------------------------------------------- + /** + * Default cache size for CTF traces + */ + protected static final int DEFAULT_CACHE_SIZE = 50000; + + //------------------------------------------- + // Fields + //------------------------------------------- - // ------------------------------------------------------------------------ - // Attributes - // ------------------------------------------------------------------------ + /** Reference to the state system assigned to this trace */ + protected IStateSystemQuerier ss = null; - // the Ctf Trace + /* Reference to the CTF Trace */ private CTFTrace fTrace; - // The cache page size AND checkpoints interval - protected int fIndexPageSize = DEFAULT_INDEX_PAGE_SIZE; - - // The set of event stream checkpoints (for random access) - private Vector fCheckpoints = new Vector(); - - // The number of events collected - protected long fNbEvents = 0; - - // The time span of the event stream - private ITmfTimestamp fStartTime = TmfTimestamp.BIG_CRUNCH; - private ITmfTimestamp fEndTime = TmfTimestamp.BIG_BANG; - - // The trace resource - private IResource fResource; - - /* - * Since in TMF, "traces" can read events, this trace here will have its own - * iterator. The user can instantiate extra iterator if they want to seek at - * many places at the same time. + //------------------------------------------- + // TmfTrace Overrides + //------------------------------------------- + /** + * Method initTrace. + * @param resource IResource + * @param path String + * @param eventType Class + * @throws TmfTraceException + * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#initTrace(IResource, String, Class) */ - protected CtfIterator iterator; - - // ------------------------------------------------------------------------ - // Constructors - // ------------------------------------------------------------------------ - - public CtfTmfTrace() { - super(); - } - @Override - public void initTrace(String name, String path, Class eventType, int pageSize) - throws FileNotFoundException { + public void initTrace(final IResource resource, final String path, final Class 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); - } catch (CTFReaderException e) { + 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); + } + + /* 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)) { + /* Handle the case where the trace is empty */ + this.setStartTime(TmfTimestamp.BIG_BANG); + } else { + this.setStartTime(iterator.getCurrentEvent().getTimestamp()); + this.setEndTime(iterator.getCurrentEvent().getTimestamp()); + } + + } catch (final CTFReaderException e) { /* * If it failed at the init(), we can assume it's because the file * was not found or was not recognized as a CTF trace. Throw into * the new type of exception expected by the rest of TMF. */ - System.err.println("Cannot find file " + path); //$NON-NLS-1$ - throw new FileNotFoundException(e.getMessage()); + throw new TmfTraceException(e.getMessage(), e); } - this.iterator = new CtfIterator(this, 0, 0); - setStartTime(iterator.getCurrentEvent().getTimestamp()); - TmfSignalManager.register(this); - // this.currLocation.setTimestamp(this.fEvent.getTimestamp().getValue()); - // this.fStartTime = new TmfSimpleTimestamp(this.currLocation - // .getLocation().getStartTime()); - // this.fEndTime = new TmfSimpleTimestamp(this.currLocation - // .getLocation().getEndTime()); - // setTimeRange(new TmfTimeRange(this.fStartTime.clone(), - // this.fEndTime.clone())); - } - - @Override - public void indexTrace(boolean waitForCompletion) { - } - @Override - public void dispose() { - TmfSignalManager.deregister(this); - } + //FIXME This should be called via the ExperimentUpdated signal + buildStateSystem(); - @Override - public void broadcast(TmfSignal signal) { - TmfSignalManager.dispatchSignal(signal); + /* 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); + } + } } + /** + * Method validate. + * @param project IProject + * @param path String + * @return boolean + * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#validate(IProject, String) + */ @Override - public boolean validate(IProject project, String path) { + public boolean validate(@SuppressWarnings("unused") final IProject project, final String path) { try { final CTFTrace temp = new CTFTrace(path); return temp.majortIsSet(); // random test - } catch (CTFReaderException e) { + } catch (final CTFReaderException e) { /* Nope, not a CTF trace we can read */ return false; } } - @Override - public CtfTmfTrace clone() throws CloneNotSupportedException { - CtfTmfTrace clone = null; - clone = (CtfTmfTrace) super.clone(); - clone.setfCheckpoints(this.fCheckpoints); - clone.fStartTime = this.fStartTime.clone(); - clone.fEndTime = this.fEndTime.clone(); - clone.fTrace = this.fTrace; - return clone; - } - - // ------------------------------------------------------------------------ - // Accessors - // ------------------------------------------------------------------------ - /** - * @return the trace path + * Method getCurrentLocation. This is not applicable in CTF + * @return null, since the trace has no knowledge of the current location + * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getCurrentLocation() */ @Override - public String getPath() { - return this.fTrace.getPath(); + public ITmfLocation getCurrentLocation() { + return null; } - @Override - public String getName() { - String temp[] = this.fTrace.getPath().split( - System.getProperty("file.separator")); //$NON-NLS-1$ - if (temp.length > 2) { - return temp[temp.length - 1]; - } - return temp[0]; - } - @Override - public int getCacheSize() { - return this.fIndexPageSize; - } @Override - public long getNbEvents() { - return this.fNbEvents; - } - - @Override - public TmfTimeRange getTimeRange() { - return new TmfTimeRange(this.fStartTime, this.fEndTime); + 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()); } + /** + * Method seekEvent. + * @param location ITmfLocation + * @return ITmfContext + * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#seekEvent(ITmfLocation) + */ @Override - public ITmfTimestamp getStartTime() { - return this.fStartTime; + public ITmfContext seekEvent(final ITmfLocation location) { + CtfLocation currentLocation = (CtfLocation) location; + CtfIterator context = new CtfIterator(this); + /* + * 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); + context.setRank(0); + } + if (currentLocation.getLocation() == CtfLocation.INVALID_LOCATION) { + ((CtfTmfTimestamp) getEndTime()).setType(TimestampType.NANOS); + currentLocation.setLocation(getEndTime().getValue() + 1); + } + context.setLocation(currentLocation); + if(context.getRank() != 0) + context.setRank(ITmfContext.UNKNOWN_RANK); + return context; } - @Override - public ITmfTimestamp getEndTime() { - return this.fEndTime; - } @Override - public ITmfLocation getCurrentLocation() { - return iterator.getLocation(); + public ITmfContext seekEvent(double ratio) { + CtfIterator context = new CtfIterator(this); + context.seek((long) (this.getNbEvents() * ratio)); + context.setRank(ITmfContext.UNKNOWN_RANK); + return context; } + /** + * Method readNextEvent. + * @param context ITmfContext + * @return CtfTmfEvent + * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getNext(ITmfContext) + */ @Override - public long getRank(ITmfTimestamp timestamp) { - ITmfContext context = seekEvent(timestamp); - return context.getRank(); - } - - // ------------------------------------------------------------------------ - // Operators - // ------------------------------------------------------------------------ - - protected void setTimeRange(TmfTimeRange range) { - this.fStartTime = range.getStartTime(); - this.fEndTime = range.getEndTime(); - } - - protected void setStartTime(ITmfTimestamp startTime) { - this.fStartTime = startTime; - } - - protected void setEndTime(ITmfTimestamp endTime) { - this.fEndTime = endTime; - } - - // ------------------------------------------------------------------------ - // TmfProvider - // ------------------------------------------------------------------------ - - @Override - public ITmfContext armRequest(ITmfDataRequest request) { - if ((request instanceof ITmfEventRequest) - && !TmfTimestamp.BIG_BANG.equals(((ITmfEventRequest) request).getRange().getStartTime()) - && (request.getIndex() == 0)) { - ITmfContext context = seekEvent(((ITmfEventRequest) request).getRange().getStartTime()); - ((ITmfEventRequest) request).setStartIndex((int) context.getRank()); - return context; + public synchronized CtfTmfEvent getNext(final ITmfContext context) { + CtfTmfEvent event = null; + if (context instanceof CtfIterator) { + CtfIterator ctfIterator = (CtfIterator) context; + event = ctfIterator.getCurrentEvent(); + + if (event != null) { + updateAttributes(context, event.getTimestamp()); + ctfIterator.advance(); + ctfIterator.increaseRank(); + } } - return seekEvent(request.getIndex()); + + return event; } /** - * The trace reader keeps its own iterator: the "context" parameter here - * will be ignored. - * - * If you wish to specify a new context, instantiate a new CtfIterator and - * seek() it to where you want, and use that to read events. - * - * FIXME merge with getNextEvent below once they both use the same parameter - * type. + * Suppressing the warning, because the 'throws' will usually happen in + * sub-classes. + * @throws TmfTraceException */ - @Override - public CtfTmfEvent getNext(ITmfContext context) { - iterator.advance(); - return iterator.getCurrentEvent(); + @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; } - // ------------------------------------------------------------------------ - // ITmfTrace - // ------------------------------------------------------------------------ - - @Override - public ITmfContext seekLocation(ITmfLocation location) { - iterator.setLocation(location); - return iterator; + /** + * Method getStateSystem. + * + * @return IStateSystemQuerier + */ + public IStateSystemQuerier getStateSystem() { + return this.ss; } - @Override - public double getLocationRatio(ITmfLocation location) { - return 0; + /** + * + * @param ed + * @return + */ + private static ITmfEventField parseDeclaration(EventDeclaration ed) { + EventDefinition eventDef = ed.createDefinition(null); + return new CtfTmfContent(ITmfEventField.ROOT_FIELD_ID, + CtfTmfEvent.parseFields(eventDef)); } - @Override - public long getStreamingInterval() { - return 0; + /** + * gets the CTFtrace that this is wrapping + * @return the CTF trace + */ + public CTFTrace getCTFTrace() { + return fTrace; } - @Override - public ITmfContext seekEvent(ITmfTimestamp timestamp) { - iterator.seek(timestamp.getValue()); - return iterator; - } + //------------------------------------------- + // Environment Parameters + //------------------------------------------- /** - * Seek by rank + * Method getNbEnvVars. + * + * @return int */ - @Override - public ITmfContext seekEvent(long rank) { - iterator.setRank(rank); - return iterator; + public int getNbEnvVars() { + return this.fTrace.getEnvironment().size(); } /** - * Seek rank ratio + * Method getEnvNames. + * + * @return String[] */ - @Override - public ITmfContext seekLocation(double ratio) { - iterator.seek((long) (this.fNbEvents * ratio)); - return iterator; + public String[] getEnvNames() { + final String[] s = new String[getNbEnvVars()]; + return this.fTrace.getEnvironment().keySet().toArray(s); } - @Override - public CtfTmfEvent getNextEvent(ITmfContext context) { - iterator.advance(); - return iterator.getCurrentEvent(); - } - - @Override - public CtfTmfEvent parseEvent(ITmfContext context) { - return iterator.getCurrentEvent(); + /** + * Method getEnvValue. + * + * @param key + * String + * @return String + */ + public String getEnvValue(final String key) { + return this.fTrace.getEnvironment().get(key); } - public Vector getfCheckpoints() { - return this.fCheckpoints; - } + //------------------------------------------- + // Clocks + //------------------------------------------- - public void setfCheckpoints(Vector fCheckpoints) { - this.fCheckpoints = fCheckpoints; + public long getOffset(){ + if( fTrace != null ) { + return fTrace.getOffset(); + } + return 0; } - @Override - public IResource getResource() { - return this.fResource; - } + //------------------------------------------- + // Parser + //------------------------------------------- @Override - public void setResource(IResource fResource) { - this.fResource = fResource; + public CtfTmfEvent parseEvent(ITmfContext context) { + CtfTmfEvent event = null; + if( context instanceof CtfIterator ){ + CtfIterator itt = (CtfIterator) context; + event = itt.getCurrentEvent(); + } + return event; } - - CTFTrace getCTFTrace() { - return fTrace; + + /** + * Sets the cache size for a CtfTmfTrace. + */ + protected void setCacheSize() { + setCacheSize(DEFAULT_CACHE_SIZE); } }