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=700b0a9d7d228c807e0bbe948349375249192527;hb=102e61914a8eef26355ca4e1430b529bfd643e48;hp=9e0ec58926d1d229f6685c785bffa4f72be42e7b;hpb=6bab45115d11024d702e1d83c41aaaa3d9bebafa;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 9e0ec58926..700b0a9d7d 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,30 +1,38 @@ /******************************************************************************* - * 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 java.util.Collections; +import java.util.Map; + import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; -import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.linuxtools.ctf.core.event.IEventDeclaration; 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.ITmfTimestamp; +import org.eclipse.linuxtools.ctf.core.trace.CTFTraceReader; +import org.eclipse.linuxtools.internal.tmf.core.Activator; import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; -import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp; 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.ITmfTraceProperties; import org.eclipse.linuxtools.tmf.core.trace.TmfTrace; /** @@ -33,32 +41,27 @@ import org.eclipse.linuxtools.tmf.core.trace.TmfTrace; * @version 1.0 * @author Matthew khouzam */ -public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ - +public class CtfTmfTrace extends TmfTrace + implements ITmfEventParser, ITmfTraceProperties { - //------------------------------------------- - // Constants - //------------------------------------------- + // ------------------------------------------- + // 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; + // ------------------------------------------- + // Fields + // ------------------------------------------- /* Reference to the CTF Trace */ private CTFTrace fTrace; - - - //------------------------------------------- - // TmfTrace Overrides - //------------------------------------------- + // ------------------------------------------- + // TmfTrace Overrides + // ------------------------------------------- /** * Method initTrace. * @@ -79,6 +82,7 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ * because the super needs to know the cache size. */ setCacheSize(); + super.initTrace(resource, path, eventType); @SuppressWarnings("unused") @@ -87,11 +91,11 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ try { this.fTrace = new CTFTrace(path); CtfIteratorManager.addTrace(this); - CtfTmfLightweightContext ctx; + CtfTmfContext ctx; /* Set the start and (current) end times for this trace */ - ctx = (CtfTmfLightweightContext) seekEvent(0L); + ctx = (CtfTmfContext) seekEvent(0L); CtfTmfEvent event = getNext(ctx); - if((ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) || (ctx.getCurrentEvent() == null)) { + if ((ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) || (ctx.getCurrentEvent() == null)) { /* Handle the case where the trace is empty */ this.setStartTime(TmfTimestamp.BIG_BANG); } else { @@ -108,132 +112,129 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ */ throw new TmfTraceException(e.getMessage(), e); } - - //FIXME This should be called via the ExperimentUpdated signal - buildStateSystem(); - - /* 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(); } /** * Method validate. - * @param project IProject - * @param path String - * @return boolean + * + * @param project + * IProject + * @param path + * String + * @return IStatus IStatus.error or Status.OK_STATUS * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#validate(IProject, String) + * @since 2.0 */ @Override - public boolean validate(final IProject project, final String path) { + public IStatus validate(final IProject project, final String path) { + IStatus validTrace = Status.OK_STATUS; try { final CTFTrace temp = new CTFTrace(path); - return temp.majortIsSet(); // random test + if (!temp.majortIsSet()) { + validTrace = new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_MajorNotSet); + } else { + CTFTraceReader ctfTraceReader = new CTFTraceReader(temp); + if (!ctfTraceReader.hasMoreEvents()) { + // TODO: This will need an additional check when we support live traces + // because having no event is valid for a live trace + validTrace = new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_NoEvent); + } + ctfTraceReader.dispose(); + } + temp.dispose(); } catch (final CTFReaderException e) { - /* Nope, not a CTF trace we can read */ - return false; + validTrace = new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_ReadingError +": " + e.toString()); //$NON-NLS-1$ } + return validTrace; } /** * 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 ITmfLocation getCurrentLocation() { + public ITmfLocation getCurrentLocation() { return null; } - - @Override - public double getLocationRatio(ITmfLocation location) { + public double getLocationRatio(ITmfLocation location) { final CtfLocation curLocation = (CtfLocation) location; - final CtfTmfLightweightContext context = new CtfTmfLightweightContext(this); + final CtfTmfContext context = new CtfTmfContext(this); context.setLocation(curLocation); - context.seek(curLocation.getLocationData()); - final CtfLocationData currentTime = ((CtfLocationData)context.getLocation().getLocationData()); + 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); } - - - - - /* (non-Javadoc) - * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#seekEvent(org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp) - */ - @Override - public synchronized ITmfContext seekEvent(ITmfTimestamp timestamp) { - if( timestamp instanceof CtfTmfTimestamp){ - CtfTmfLightweightContext iter = new CtfTmfLightweightContext(this); - iter.seek(timestamp.getValue()); - return iter; - } - return super.seekEvent(timestamp); - } - /** * Method seekEvent. - * @param location ITmfLocation + * + * @param location + * ITmfLocation * @return ITmfContext */ @Override - public ITmfContext seekEvent(final ITmfLocation location) { + public synchronized ITmfContext seekEvent(final ITmfLocation location) { CtfLocation currentLocation = (CtfLocation) location; - CtfTmfLightweightContext context = new CtfTmfLightweightContext(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(new CtfLocationData(0L, 0L)); + currentLocation = new CtfLocation(new CtfLocationInfo(0L, 0L)); context.setRank(0); } - if (currentLocation.getLocationData() == CtfLocation.INVALID_LOCATION) { - ((CtfTmfTimestamp) getEndTime()).setType(TimestampType.NANOS); - currentLocation.setLocation(getEndTime().getValue() + 1, 0L); + if (currentLocation.getLocationInfo() == CtfLocation.INVALID_LOCATION) { + currentLocation = new CtfLocation(getEndTime().getValue() + 1, 0L); } context.setLocation(currentLocation); if (location == null) { CtfTmfEvent event = getIterator(this, context).getCurrentEvent(); if (event != null) { - currentLocation.setLocation(event.getTimestamp().getValue(), 0); + currentLocation = new CtfLocation(event.getTimestamp().getValue(), 0); } } - if(context.getRank() != 0) { + if (context.getRank() != 0) { context.setRank(ITmfContext.UNKNOWN_RANK); } return context; } - @Override - public ITmfContext seekEvent(double ratio) { - CtfTmfLightweightContext context = new CtfTmfLightweightContext(this); + 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 = (long) (diff * ratio) + start; + final long ratioTs = Math.round(diff * ratio) + start; context.seek(ratioTs); context.setRank(ITmfContext.UNKNOWN_RANK); return context; @@ -241,18 +242,23 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ /** * Method readNextEvent. - * @param context ITmfContext + * + * @param context + * ITmfContext * @return CtfTmfEvent * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getNext(ITmfContext) */ @Override public synchronized CtfTmfEvent getNext(final ITmfContext context) { + if (fTrace == null) { + return null; + } CtfTmfEvent event = null; - if (context instanceof CtfTmfLightweightContext) { - if (CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationData())) { + if (context instanceof CtfTmfContext) { + if (context.getLocation() == null || CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationInfo())) { return null; } - CtfTmfLightweightContext ctfContext = (CtfTmfLightweightContext) context; + CtfTmfContext ctfContext = (CtfTmfContext) context; event = ctfContext.getCurrentEvent(); if (event != null) { @@ -266,96 +272,109 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ } /** - * Suppressing the warning, because the 'throws' will usually happen in - * sub-classes. + * gets the CTFtrace that this is wrapping * - * @throws TmfTraceException + * @return the CTF trace */ - @SuppressWarnings("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; + public CTFTrace getCTFTrace() { + return fTrace; } - /** - * Method getStateSystem. - * - * @return IStateSystemQuerier - */ - public IStateSystemQuerier getStateSystem() { - return this.ss; - } + // ------------------------------------------- + // ITmfTraceProperties + // ------------------------------------------- /** - * gets the CTFtrace that this is wrapping - * @return the CTF trace + * @since 2.0 */ - public CTFTrace getCTFTrace() { - return fTrace; + @Override + public Map getTraceProperties() { + return Collections.unmodifiableMap(fTrace.getEnvironment()); } + // ------------------------------------------- + // Clocks + // ------------------------------------------- - //------------------------------------------- - // Environment Parameters - //------------------------------------------- /** - * Method getNbEnvVars. + * gets the clock offset * - * @return int + * @return the clock offset in ns */ - public int getNbEnvVars() { - return this.fTrace.getEnvironment().size(); + public long getOffset() { + if (fTrace != null) { + return fTrace.getOffset(); + } + return 0; } /** - * Method getEnvNames. + * Returns whether or not an event is in the metadata of the trace, + * therefore if it can possibly be in the trace. It does not verify whether + * or not the event is actually in the trace * - * @return String[] + * @param eventName + * The name of the event to check + * @return Whether the event is in the metadata or not + * @since 2.1 */ - public String[] getEnvNames() { - final String[] s = new String[getNbEnvVars()]; - return this.fTrace.getEnvironment().keySet().toArray(s); + public boolean hasEvent(final String eventName) { + Map events = fTrace.getEvents(0L); + if (events != null) { + for (IEventDeclaration decl : events.values()) { + if (decl.getName().equals(eventName)) { + return true; + } + } + } + return false; } /** - * Method getEnvValue. + * Return whether all requested events are in the metadata * - * @param key - * String - * @return String + * @param names + * The array of events to check for + * @return Whether all events are in the metadata + * @since 2.1 */ - public String getEnvValue(final String key) { - return this.fTrace.getEnvironment().get(key); + public boolean hasAllEvents(String[] names) { + for (String name : names) { + if (!hasEvent(name)) { + return false; + } + } + return true; } - //------------------------------------------- - // Clocks - //------------------------------------------- - /** - * gets the clock offset - * @return the clock offset in ns + * Returns whether the metadata contains at least one of the requested + * events + * + * @param names + * The array of event names of check for + * @return Whether one of the event is present in trace metadata + * @since 2.1 */ - public long getOffset(){ - if( fTrace != null ) { - return fTrace.getOffset(); + public boolean hasAtLeastOneOfEvents(String[] names) { + for (String name : names) { + if (hasEvent(name)) { + return true; + } } - return 0; + return false; } - //------------------------------------------- - // Parser - //------------------------------------------- + // ------------------------------------------- + // Parser + // ------------------------------------------- @Override public CtfTmfEvent parseEvent(ITmfContext context) { CtfTmfEvent event = null; - if( context instanceof CtfTmfLightweightContext ){ - CtfTmfLightweightContext itt = (CtfTmfLightweightContext) context.clone(); - event = itt.getCurrentEvent(); + if (context instanceof CtfTmfContext) { + final ITmfContext tmpContext = seekEvent(context.getLocation()); + event = getNext(tmpContext); } return event; } @@ -367,11 +386,21 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{ setCacheSize(DEFAULT_CACHE_SIZE); } - //------------------------------------------- - // Helpers - //------------------------------------------- + // ------------------------------------------- + // Helpers + // ------------------------------------------- - private static CtfIterator getIterator(CtfTmfTrace trace, CtfTmfLightweightContext context) { + 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); + } }