org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/viewers/events/TmfEventsCache.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2014 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made 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:
  10  *   Patrick Tasse - Initial API and implementation
  11  *   Bernd Hufmann - Add support for event collapsing
  12  ******************************************************************************/
  13
  14 package org.eclipse.tracecompass.tmf.ui.viewers.events;
  15
  16 import java.util.ArrayList;
  17 import java.util.Arrays;
  18 import java.util.List;
  19
  20 import org.eclipse.core.runtime.IProgressMonitor;
  21 import org.eclipse.core.runtime.IStatus;
  22 import org.eclipse.core.runtime.Status;
  23 import org.eclipse.core.runtime.jobs.Job;
  24 import org.eclipse.tracecompass.internal.tmf.core.filter.TmfCollapseFilter;
  25 import org.eclipse.tracecompass.internal.tmf.ui.Activator;
  26 import org.eclipse.tracecompass.tmf.core.component.ITmfEventProvider;
  27 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  28 import org.eclipse.tracecompass.tmf.core.event.ITmfEventField;
  29 import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
  30 import org.eclipse.tracecompass.tmf.core.filter.ITmfFilter;
  31 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  32 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  33 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  34 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  35 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  36
  37 /**
  38  * The generic TMF Events table events cache
  39  *
  40  * This can help avoid re-reading the trace when the user scrolls a window,
  41  * for example.
  42  *
  43  * @author Patrick Tasse
  44  */
  45 public class TmfEventsCache {
  46
  47     /**
  48      * The generic TMF Events table cached event.
  49      *
  50      * @author Patrick Tasse
  51      */
  52     public static class CachedEvent implements ITmfEvent {
  53         /**
  54          * Event reference.
  55          *
  56          * When {@link TmfCollapseFilter} is active then it's event reference
  57          * of the first event of repeated events.
  58          */
  59         ITmfEvent event;
  60         /**
  61          * Events rank.
  62          *
  63          * When {@link TmfCollapseFilter} is active then it's event rank of the
  64          * first event of repeated events.
  65          */
  66         long rank;
  67         /**
  68          * Number times event is repeated. Updated by using {@link TmfCollapseFilter}
  69          */
  70         long repeatCount;
  71
  72         /**
  73          * Constructor for new cached events.
  74          *
  75          * @param iTmfEvent
  76          *            The original trace event
  77          * @param rank
  78          *            The rank of this event in the trace
  79          */
  80         public CachedEvent (ITmfEvent iTmfEvent, long rank) {
  81             this.event = iTmfEvent;
  82             this.rank = rank;
  83         }
  84
  85         @Override
  86         public Object getAdapter(Class adapter) {
  87             return event.getAdapter(adapter);
  88         }
  89
  90         @Override
  91         public ITmfTrace getTrace() {
  92             return event.getTrace();
  93         }
  94
  95         @Override
  96         public long getRank() {
  97             return event.getRank();
  98         }
  99
 100         @Override
 101         public ITmfTimestamp getTimestamp() {
 102             return event.getTimestamp();
 103         }
 104
 105         @Override
 106         public ITmfEventType getType() {
 107             return event.getType();
 108         }
 109
 110         @Override
 111         public ITmfEventField getContent() {
 112             return event.getContent();
 113         }
 114     }
 115
 116     private final CachedEvent[] fCache;
 117     private final int fCacheSize;
 118     private int fCacheStartIndex = 0;
 119     private int fCacheEndIndex   = 0;
 120
 121     private ITmfTrace fTrace;
 122     private final TmfEventsTable fTable;
 123     private ITmfFilter fFilter;
 124     private final List<Integer> fFilterIndex = new ArrayList<>(); // contains the event rank at each 'cache size' filtered events
 125
 126     /**
 127      * Constructor for the event cache
 128      *
 129      * @param cacheSize
 130      *            The size of the cache, in number of events
 131      * @param table
 132      *            The Events table this cache will cover
 133      */
 134     public TmfEventsCache(int cacheSize, TmfEventsTable table) {
 135         fCacheSize = cacheSize;
 136         fCache = new CachedEvent[cacheSize * 2]; // the cache holds two blocks of cache size
 137         fTable = table;
 138     }
 139
 140     /**
 141      * Assign a new trace to this events cache. This clears the current
 142      * contents.
 143      *
 144      * @param trace
 145      *            The trace to assign.
 146      */
 147     public void setTrace(ITmfTrace trace) {
 148         fTrace = trace;
 149         clear();
 150     }
 151
 152     /**
 153      * Clear the current contents of this cache.
 154      */
 155     public synchronized void clear() {
 156         if (job != null && job.getState() != Job.NONE) {
 157             job.cancel();
 158         }
 159         Arrays.fill(fCache, null);
 160         fCacheStartIndex = 0;
 161         fCacheEndIndex = 0;
 162         fFilterIndex.clear();
 163     }
 164
 165     /**
 166      * Apply a filter on this event cache. This clears the current cache
 167      * contents.
 168      *
 169      * @param filter
 170      *            The ITmfFilter to apply.
 171      */
 172     public void applyFilter(ITmfFilter filter) {
 173         fFilter = filter;
 174         clear();
 175     }
 176
 177     /**
 178      * Clear the current filter on this cache. This also clears the current
 179      * cache contents.
 180      */
 181     public void clearFilter() {
 182         fFilter = null;
 183         clear();
 184     }
 185
 186     /**
 187      * Get an event from the cache. If the cache does not contain the event,
 188      * a cache population request is triggered.
 189      *
 190      * @param index
 191      *            The index of this event in the cache
 192      * @return The cached event, or 'null' if the event is not in the cache
 193      */
 194     public synchronized CachedEvent getEvent(int index) {
 195         if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {
 196             int i = index - fCacheStartIndex;
 197             return fCache[i];
 198         }
 199         populateCache(index);
 200         return null;
 201     }
 202
 203     /**
 204      * Peek an event in the cache. Does not trigger cache population.
 205      *
 206      * @param index
 207      *            Index of the event to peek
 208      * @return The cached event, or 'null' if the event is not in the cache
 209      */
 210     public synchronized CachedEvent peekEvent(int index) {
 211         if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {
 212             int i = index - fCacheStartIndex;
 213             return fCache[i];
 214         }
 215         return null;
 216     }
 217
 218     /**
 219      * Add a trace event to the cache.
 220      *
 221      * @param event
 222      *            The original trace event to be cached
 223      * @param rank
 224      *            The rank of this event in the trace
 225      * @param index
 226      *            The index this event will occupy in the cache
 227      */
 228     public synchronized void storeEvent(ITmfEvent event, long rank, int index) {
 229         if (index == fCacheEndIndex) {
 230             int i = index - fCacheStartIndex;
 231             if (i < fCache.length) {
 232                 fCache[i] = new CachedEvent(event, rank);
 233                 fCacheEndIndex++;
 234             }
 235         }
 236         if ((fFilter != null) && ((index % fCacheSize) == 0)) {
 237             int i = index / fCacheSize;
 238             fFilterIndex.add(i, Integer.valueOf((int) rank));
 239         }
 240     }
 241
 242     /**
 243      * Update event repeat count at index
 244      *
 245      * @param index
 246      *            The index this event occupies in the cache
 247      */
 248     public synchronized void updateCollapsedEvent(int index) {
 249         int i = index - fCacheStartIndex;
 250         if (i < fCache.length) {
 251             fCache[i].repeatCount++;
 252         }
 253     }
 254
 255     /**
 256      * Get the cache index of an event from his rank in the trace. This will
 257      * take in consideration any filter that might be applied.
 258      *
 259      * @param rank
 260      *            The rank of the event in the trace
 261      * @return The position (index) this event should use once cached
 262      */
 263     public int getFilteredEventIndex(final long rank) {
 264         int current;
 265         int startRank;
 266         TmfEventRequest request;
 267         final ITmfFilter filter = fFilter;
 268         synchronized (this) {
 269             int start = 0;
 270             int end = fFilterIndex.size();
 271
 272             if ((fCacheEndIndex - fCacheStartIndex) > 1) {
 273                 if (rank < fCache[0].rank) {
 274                     end = (fCacheStartIndex / fCacheSize) + 1;
 275                 } else if (rank > fCache[fCacheEndIndex - fCacheStartIndex - 1].rank) {
 276                     start = fCacheEndIndex / fCacheSize;
 277                 } else {
 278                     for (int i = 0; i < (fCacheEndIndex - fCacheStartIndex); i++) {
 279                         if (fCache[i].rank >= rank) {
 280                             return fCacheStartIndex + i;
 281                         }
 282                     }
 283                     return fCacheEndIndex;
 284                 }
 285             }
 286
 287             current = (start + end) / 2;
 288             while (current != start) {
 289                 if (rank < fFilterIndex.get(current)) {
 290                     end = current;
 291                     current = (start + end) / 2;
 292                 } else {
 293                     start = current;
 294                     current = (start + end) / 2;
 295                 }
 296             }
 297             startRank = fFilterIndex.size() > 0 ? fFilterIndex.get(current) : 0;
 298         }
 299
 300         final int index = current * fCacheSize;
 301
 302         class DataRequest extends TmfEventRequest {
 303             ITmfFilter requestFilter;
 304             int requestRank;
 305             int requestIndex;
 306
 307             DataRequest(Class<? extends ITmfEvent> dataType, ITmfFilter reqFilter, int start, int nbRequested) {
 308                 super(dataType, TmfTimeRange.ETERNITY, start, nbRequested,
 309                         TmfEventRequest.ExecutionType.FOREGROUND);
 310                 requestFilter = reqFilter;
 311                 requestRank = start;
 312                 requestIndex = index;
 313             }
 314
 315             @Override
 316             public void handleData(ITmfEvent event) {
 317                 super.handleData(event);
 318                 if (isCancelled()) {
 319                     return;
 320                 }
 321                 if (requestRank >= rank) {
 322                     cancel();
 323                     return;
 324                 }
 325                 requestRank++;
 326                 if (requestFilter.matches(event)) {
 327                     requestIndex++;
 328                 }
 329             }
 330
 331             public int getFilteredIndex() {
 332                 return requestIndex;
 333             }
 334         }
 335
 336         request = new DataRequest(ITmfEvent.class, filter, startRank, ITmfEventRequest.ALL_DATA);
 337         ((ITmfEventProvider) fTrace).sendRequest(request);
 338         try {
 339             request.waitForCompletion();
 340             return ((DataRequest) request).getFilteredIndex();
 341         } catch (InterruptedException e) {
 342             Activator.getDefault().logError("Filter request interrupted!", e); //$NON-NLS-1$
 343         }
 344         return 0;
 345     }
 346
 347     // ------------------------------------------------------------------------
 348     // Event cache population
 349     // ------------------------------------------------------------------------
 350
 351     // The event fetching job
 352     private Job job;
 353     private synchronized void populateCache(final int index) {
 354
 355         /* Check if the current job will fetch the requested event:
 356          * 1. The job must exist
 357          * 2. It must be running (i.e. not completed)
 358          * 3. The requested index must be within the cache range
 359          *
 360          * If the job meets these conditions, we simply exit.
 361          * Otherwise, we create a new job but we might have to cancel
 362          * an existing job for an obsolete range.
 363          */
 364         if (job != null) {
 365             if (job.getState() != Job.NONE) {
 366                 if ((index >= fCacheStartIndex) && (index < (fCacheStartIndex + fCache.length))) {
 367                     return;
 368                 }
 369                 // The new index is out of the requested range
 370                 // Kill the job and start a new one
 371                 job.cancel();
 372             }
 373         }
 374
 375         // Populate the cache starting at the index that is one block less
 376         // of cache size than the requested index. The cache will hold two
 377         // consecutive blocks of cache size, centered on the requested index.
 378         fCacheStartIndex = Math.max(0, index - fCacheSize);
 379         fCacheEndIndex   = fCacheStartIndex;
 380
 381         job = new Job("Fetching Events") { //$NON-NLS-1$
 382             private int startIndex = fCacheStartIndex;
 383             private int skipCount = 0;
 384             @Override
 385             protected IStatus run(final IProgressMonitor monitor) {
 386
 387                 int nbRequested;
 388                 if (fFilter == null) {
 389                     nbRequested = fCache.length;
 390                 } else {
 391                     nbRequested = ITmfEventRequest.ALL_DATA;
 392                     int i = startIndex / fCacheSize;
 393                     if (i < fFilterIndex.size()) {
 394                         skipCount = startIndex - (i * fCacheSize);
 395                         startIndex = fFilterIndex.get(i);
 396                     }
 397                 }
 398
 399                 TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
 400                         TmfTimeRange.ETERNITY,
 401                         startIndex,
 402                         nbRequested,
 403                         TmfEventRequest.ExecutionType.FOREGROUND) {
 404                     private int count = 0;
 405                     private long rank = startIndex;
 406                     @Override
 407                     public void handleData(ITmfEvent event) {
 408                         // If the job is canceled, cancel the request so waitForCompletion() will unlock
 409                         if (monitor.isCanceled()) {
 410                             cancel();
 411                             return;
 412                         }
 413                         super.handleData(event);
 414                         if (((fFilter == null) || fFilter.matches(event)) && (skipCount-- <= 0)) {
 415                             synchronized (TmfEventsCache.this) {
 416                                 if (monitor.isCanceled()) {
 417                                     return;
 418                                 }
 419                                 fCache[count] = new CachedEvent(event, rank);
 420                                 count++;
 421                                 fCacheEndIndex++;
 422                             }
 423                             if (fFilter != null) {
 424                                 fTable.cacheUpdated(false);
 425                             }
 426                         } else if (((fFilter != null) && !fFilter.matches(event)) && (skipCount <= 0)) { // TODO fix duplicated call to matches()
 427                             if ((count > 0) && (fFilter instanceof TmfCollapseFilter)) {
 428                                 fCache[count - 1].repeatCount++;
 429                             }
 430                         }
 431                         if (count >= fCache.length) {
 432                             cancel();
 433                         } else if ((fFilter != null) && (count >= (fTable.getTable().getItemCount() - 3))) { // -1 for header row, -2 for top and bottom filter status rows
 434                             cancel();
 435                         }
 436                         rank++;
 437                     }
 438                 };
 439
 440                 ((ITmfEventProvider) fTrace).sendRequest(request);
 441                 try {
 442                     request.waitForCompletion();
 443                 } catch (InterruptedException e) {
 444                     Activator.getDefault().logError("Wait for completion interrupted for populateCache ", e); //$NON-NLS-1$
 445                 }
 446
 447                 fTable.cacheUpdated(true);
 448
 449                 // Flag the UI thread that the cache is ready
 450                 if (monitor.isCanceled()) {
 451                     return Status.CANCEL_STATUS;
 452                 }
 453                 return Status.OK_STATUS;
 454             }
 455         };
 456         //job.setSystem(true);
 457         job.setPriority(Job.SHORT);
 458         job.schedule();
 459     }
 460
 461 }