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=3b546fb208bdac4a9ed0e90fd3ed5faa1c60a647;hpb=2e75ef6e4e31f4372f98e841de6cefef064e0340;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 3b546fb208..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,28 +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.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.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.ITmfTimestamp; -import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp; import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException; -import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem; +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; /** @@ -31,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 ITmfStateSystem ss = null; + // ------------------------------------------- + // Fields + // ------------------------------------------- /* Reference to the CTF Trace */ private CTFTrace fTrace; - - - //------------------------------------------- - // TmfTrace Overrides - //------------------------------------------- + // ------------------------------------------- + // TmfTrace Overrides + // ------------------------------------------- /** * Method initTrace. * @@ -78,17 +83,19 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { */ setCacheSize(); + super.initTrace(resource, path, eventType); + @SuppressWarnings("unused") CtfTmfEventType type; 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 { @@ -105,40 +112,55 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { */ throw new TmfTraceException(e.getMessage(), e); } - - super.initTrace(resource, path, eventType); } - /* (non-Javadoc) - * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#dispose() - */ @Override public synchronized void dispose() { CtfIteratorManager.removeTrace(this); - fTrace = null; + 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() */ @@ -150,10 +172,10 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { @Override 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.getLocationInfo()); - final CtfLocationData currentTime = ((CtfLocationData)context.getLocation().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) @@ -162,20 +184,27 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { /** * 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.getLocationInfo() == CtfLocation.INVALID_LOCATION) { @@ -188,16 +217,20 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { 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; @@ -209,7 +242,9 @@ 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) */ @@ -219,11 +254,11 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { return null; } CtfTmfEvent event = null; - if (context instanceof CtfTmfLightweightContext) { - if (CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationInfo())) { + 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) { @@ -236,81 +271,110 @@ public class CtfTmfTrace extends TmfTrace implements ITmfEventParser { return event; } - /** - * @since 2.0 - */ - @Override - public ITmfStateSystem getStateSystem() { - return this.ss; - } - /** * gets the CTFtrace that this is wrapping + * * @return the CTF trace */ public CTFTrace getCTFTrace() { return fTrace; } + // ------------------------------------------- + // ITmfTraceProperties + // ------------------------------------------- - //------------------------------------------- - // Environment Parameters - //------------------------------------------- /** - * Method getNbEnvVars. - * - * @return int + * @since 2.0 */ - public int getNbEnvVars() { - return this.fTrace.getEnvironment().size(); + @Override + public Map getTraceProperties() { + return Collections.unmodifiableMap(fTrace.getEnvironment()); } + // ------------------------------------------- + // Clocks + // ------------------------------------------- + /** - * Method getEnvNames. + * gets the clock offset * - * @return String[] + * @return the clock offset in ns */ - public String[] getEnvNames() { - final String[] s = new String[getNbEnvVars()]; - return this.fTrace.getEnvironment().keySet().toArray(s); + public long getOffset() { + if (fTrace != null) { + return fTrace.getOffset(); + } + return 0; } /** - * Method getEnvValue. + * 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 * - * @param key - * String - * @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 getEnvValue(final String key) { - return this.fTrace.getEnvironment().get(key); + 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; } - //------------------------------------------- - // Clocks - //------------------------------------------- + /** + * Return whether all requested events are in the metadata + * + * @param names + * The array of events to check for + * @return Whether all events are in the metadata + * @since 2.1 + */ + public boolean hasAllEvents(String[] names) { + for (String name : names) { + if (!hasEvent(name)) { + return false; + } + } + return true; + } /** - * 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; } @@ -322,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); + } }