org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfTrace.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors: Matthew Khouzam - Initial API and implementation
  10  *******************************************************************************/
  11
  12 package org.eclipse.linuxtools.tmf.core.ctfadaptor;
  13
  14 import org.eclipse.core.resources.IProject;
  15 import org.eclipse.core.resources.IResource;
  16 import org.eclipse.core.runtime.CoreException;
  17 import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException;
  18 import org.eclipse.linuxtools.ctf.core.trace.CTFTrace;
  19 import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp.TimestampType;
  20 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  21 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  22 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  23 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  24 import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier;
  25 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  26 import org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser;
  27 import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
  28 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  29
  30 /**
  31  * The CTf trace handler
  32  *
  33  * @version 1.0
  34  * @author Matthew khouzam
  35  */
  36 public class CtfTmfTrace extends TmfTrace implements ITmfEventParser{
  37
  38
  39     //-------------------------------------------
  40     //        Constants
  41     //-------------------------------------------
  42     /**
  43      * Default cache size for CTF traces
  44      */
  45     protected static final int DEFAULT_CACHE_SIZE = 50000;
  46
  47     //-------------------------------------------
  48     //        Fields
  49     //-------------------------------------------
  50
  51     /** Reference to the state system assigned to this trace */
  52     protected IStateSystemQuerier ss = null;
  53
  54     /* Reference to the CTF Trace */
  55     private CTFTrace fTrace;
  56
  57
  58
  59     //-------------------------------------------
  60     //        TmfTrace Overrides
  61     //-------------------------------------------
  62     /**
  63      * Method initTrace.
  64      *
  65      * @param resource
  66      *            The resource associated with this trace
  67      * @param path
  68      *            The path to the trace file
  69      * @param eventType
  70      *            The type of events that will be read from this trace
  71      * @throws TmfTraceException
  72      *             If something when wrong while reading the trace
  73      */
  74     @Override
  75     public void initTrace(final IResource resource, final String path, final Class<? extends ITmfEvent> eventType)
  76             throws TmfTraceException {
  77         /*
  78          * Set the cache size. This has to be done before the call to super()
  79          * because the super needs to know the cache size.
  80          */
  81         setCacheSize();
  82         super.initTrace(resource, path, eventType);
  83
  84         @SuppressWarnings("unused")
  85         CtfTmfEventType type;
  86
  87         try {
  88             this.fTrace = new CTFTrace(path);
  89             CtfIteratorManager.addTrace(this);
  90             CtfTmfLightweightContext ctx;
  91             /* Set the start and (current) end times for this trace */
  92             ctx = (CtfTmfLightweightContext) seekEvent(0L);
  93             CtfTmfEvent event = getNext(ctx);
  94             if(ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) {
  95                 /* Handle the case where the trace is empty */
  96                 this.setStartTime(TmfTimestamp.BIG_BANG);
  97             } else {
  98                 final ITmfTimestamp curTime = event.getTimestamp();
  99                 this.setStartTime(curTime);
 100                 this.setEndTime(curTime);
 101             }
 102
 103         } catch (final CTFReaderException e) {
 104             /*
 105              * If it failed at the init(), we can assume it's because the file
 106              * was not found or was not recognized as a CTF trace. Throw into
 107              * the new type of exception expected by the rest of TMF.
 108              */
 109             throw new TmfTraceException(e.getMessage(), e);
 110         }
 111
 112         //FIXME This should be called via the ExperimentUpdated signal
 113         buildStateSystem();
 114
 115         /* Refresh the project, so it can pick up new files that got created. */
 116         if ( resource != null) {
 117             try {
 118                 resource.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
 119             } catch (CoreException e) {
 120                 throw new TmfTraceException(e.getMessage(), e);
 121             }
 122         }
 123     }
 124
 125     /* (non-Javadoc)
 126      * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#dispose()
 127      */
 128     @Override
 129     public synchronized void dispose() {
 130         CtfIteratorManager.removeTrace(this);
 131         super.dispose();
 132     }
 133
 134     /**
 135      * Method validate.
 136      * @param project IProject
 137      * @param path String
 138      * @return boolean
 139      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#validate(IProject, String)
 140      */
 141     @Override
 142     public boolean validate(final IProject project, final String path) {
 143         try {
 144             final CTFTrace temp = new CTFTrace(path);
 145             return temp.majortIsSet(); // random test
 146         } catch (final CTFReaderException e) {
 147             /* Nope, not a CTF trace we can read */
 148             return false;
 149         }
 150     }
 151
 152     /**
 153      * Method getCurrentLocation. This is not applicable in CTF
 154      * @return null, since the trace has no knowledge of the current location
 155      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getCurrentLocation()
 156      */
 157     @Override
 158     public ITmfLocation<?> getCurrentLocation() {
 159         return null;
 160     }
 161
 162
 163
 164     @Override
 165     public double getLocationRatio(ITmfLocation<?> location) {
 166         final CtfLocation curLocation = (CtfLocation) location;
 167         final CtfTmfLightweightContext context = new CtfTmfLightweightContext(this);
 168         context.setLocation(curLocation);
 169         context.seek(curLocation.getLocation());
 170         final CtfLocationData currentTime = ((CtfLocationData)context.getLocation().getLocation());
 171         final long startTime = getIterator(this, context).getStartTime();
 172         final long endTime = getIterator(this, context).getEndTime();
 173         return ((double) currentTime.getTimestamp() - startTime)
 174                 / (endTime - startTime);
 175     }
 176
 177
 178
 179
 180
 181     /* (non-Javadoc)
 182      * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#seekEvent(org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp)
 183      */
 184     @Override
 185     public synchronized ITmfContext seekEvent(ITmfTimestamp timestamp) {
 186         if( timestamp instanceof CtfTmfTimestamp){
 187             CtfTmfLightweightContext iter = new CtfTmfLightweightContext(this);
 188             iter.seek(timestamp.getValue());
 189             return iter;
 190         }
 191         return super.seekEvent(timestamp);
 192     }
 193
 194     /**
 195      * Method seekEvent.
 196      * @param location ITmfLocation<?>
 197      * @return ITmfContext
 198      */
 199     @Override
 200     public ITmfContext seekEvent(final ITmfLocation<?> location) {
 201         CtfLocation currentLocation = (CtfLocation) location;
 202         CtfTmfLightweightContext context = new CtfTmfLightweightContext(this);
 203         /*
 204          * The rank is set to 0 if the iterator seeks the beginning. If not, it
 205          * will be set to UNKNOWN_RANK, since CTF traces don't support seeking
 206          * by rank for now.
 207          */
 208         if (currentLocation == null) {
 209             currentLocation = new CtfLocation(new CtfLocationData(0L, 0L));
 210             context.setRank(0);
 211         }
 212         if (currentLocation.getLocation() == CtfLocation.INVALID_LOCATION) {
 213             ((CtfTmfTimestamp) getEndTime()).setType(TimestampType.NANOS);
 214             currentLocation.setLocation(getEndTime().getValue() + 1, 0L);
 215         }
 216         context.setLocation(currentLocation);
 217         if (location == null) {
 218             CtfTmfEvent event = getIterator(this, context).getCurrentEvent();
 219             if (event != null) {
 220                 currentLocation.setLocation(event.getTimestampValue(), 0);
 221             }
 222         }
 223         if(context.getRank() != 0) {
 224             context.setRank(ITmfContext.UNKNOWN_RANK);
 225         }
 226         return context;
 227     }
 228
 229
 230     @Override
 231     public ITmfContext seekEvent(double ratio) {
 232         CtfTmfLightweightContext context = new CtfTmfLightweightContext(this);
 233         final long end = this.getEndTime().getValue();
 234         final long start = this.getStartTime().getValue();
 235         final long diff = end - start;
 236         final long ratioTs = (long) (diff * ratio) + start;
 237         context.seek(ratioTs);
 238         context.setRank(ITmfContext.UNKNOWN_RANK);
 239         return context;
 240     }
 241
 242     /**
 243      * Method readNextEvent.
 244      * @param context ITmfContext
 245      * @return CtfTmfEvent
 246      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getNext(ITmfContext)
 247      */
 248     @Override
 249     public synchronized CtfTmfEvent getNext(final ITmfContext context) {
 250         CtfTmfEvent event = null;
 251         if (context instanceof CtfTmfLightweightContext) {
 252             if (CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocation())) {
 253                 return null;
 254             }
 255             CtfTmfLightweightContext ctfContext = (CtfTmfLightweightContext) context;
 256             event = ctfContext.getCurrentEvent();
 257
 258             if (event != null) {
 259                 updateAttributes(context, event.getTimestamp());
 260                 ctfContext.advance();
 261                 ctfContext.increaseRank();
 262             }
 263         }
 264
 265         return event;
 266     }
 267
 268     /**
 269      * Suppressing the warning, because the 'throws' will usually happen in
 270      * sub-classes.
 271      *
 272      * @throws TmfTraceException
 273      */
 274     @SuppressWarnings("unused")
 275     protected void buildStateSystem() throws TmfTraceException {
 276         /*
 277          * Nothing is done in the basic implementation, please specify
 278          * how/if to build a state system in derived classes.
 279          */
 280         return;
 281     }
 282
 283     /**
 284      * Method getStateSystem.
 285      *
 286      * @return IStateSystemQuerier
 287      */
 288     public IStateSystemQuerier getStateSystem() {
 289         return this.ss;
 290     }
 291
 292     /**
 293      * gets the CTFtrace that this is wrapping
 294      * @return the CTF trace
 295      */
 296     public CTFTrace getCTFTrace() {
 297         return fTrace;
 298     }
 299
 300
 301     //-------------------------------------------
 302     //        Environment Parameters
 303     //-------------------------------------------
 304     /**
 305      * Method getNbEnvVars.
 306      *
 307      * @return int
 308      */
 309     public int getNbEnvVars() {
 310         return this.fTrace.getEnvironment().size();
 311     }
 312
 313     /**
 314      * Method getEnvNames.
 315      *
 316      * @return String[]
 317      */
 318     public String[] getEnvNames() {
 319         final String[] s = new String[getNbEnvVars()];
 320         return this.fTrace.getEnvironment().keySet().toArray(s);
 321     }
 322
 323     /**
 324      * Method getEnvValue.
 325      *
 326      * @param key
 327      *            String
 328      * @return String
 329      */
 330     public String getEnvValue(final String key) {
 331         return this.fTrace.getEnvironment().get(key);
 332     }
 333
 334     //-------------------------------------------
 335     //        Clocks
 336     //-------------------------------------------
 337
 338     /**
 339      * gets the clock offset
 340      * @return the clock offset in ns
 341      */
 342     public long getOffset(){
 343         if( fTrace != null ) {
 344             return fTrace.getOffset();
 345         }
 346         return 0;
 347     }
 348
 349     //-------------------------------------------
 350     //        Parser
 351     //-------------------------------------------
 352
 353     @Override
 354     public CtfTmfEvent parseEvent(ITmfContext context) {
 355         CtfTmfEvent event = null;
 356         if( context instanceof CtfTmfLightweightContext ){
 357             CtfTmfLightweightContext itt = (CtfTmfLightweightContext) context.clone();
 358             event = itt.getCurrentEvent();
 359         }
 360         return event;
 361     }
 362
 363     /**
 364      * Sets the cache size for a CtfTmfTrace.
 365      */
 366     protected void setCacheSize() {
 367         setCacheSize(DEFAULT_CACHE_SIZE);
 368     }
 369
 370     //-------------------------------------------
 371     //          Helpers
 372     //-------------------------------------------
 373
 374     private static CtfIterator getIterator(CtfTmfTrace trace,  CtfTmfLightweightContext context) {
 375         return CtfIteratorManager.getIterator(trace, context);
 376     }
 377 }