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          * @since 3.2
  86          */
  87         @Override
  88         public Object getAdapter(Class adapter) {
  89             return event.getAdapter(adapter);
  90         }
  91         /**
  92          * @since 3.2
  93          */
  94         @Override
  95         public ITmfTrace getTrace() {
  96             return event.getTrace();
  97         }
  98         /**
  99          * @since 3.2
 100          */
 101         @Override
 102         public long getRank() {
 103             return event.getRank();
 104         }
 105         /**
 106          * @since 3.2
 107          */
 108         @Override
 109         public ITmfTimestamp getTimestamp() {
 110             return event.getTimestamp();
 111         }
 112         /**
 113          * @since 3.2
 114          */
 115         @Override
 116         public String getSource() {
 117             return event.getSource();
 118         }
 119         /**
 120          * @since 3.2
 121          */
 122         @Override
 123         public ITmfEventType getType() {
 124             return event.getType();
 125         }
 126         /**
 127          * @since 3.2
 128          */
 129         @Override
 130         public ITmfEventField getContent() {
 131             return event.getContent();
 132         }
 133         /**
 134          * @since 3.2
 135          */
 136         @Override
 137         public String getReference() {
 138             return event.getReference();
 139         }
 140     }
 141
 142     private final CachedEvent[] fCache;
 143     private final int fCacheSize;
 144     private int fCacheStartIndex = 0;
 145     private int fCacheEndIndex   = 0;
 146
 147     private ITmfTrace fTrace;
 148     private final TmfEventsTable fTable;
 149     private ITmfFilter fFilter;
 150     private final List<Integer> fFilterIndex = new ArrayList<>(); // contains the event rank at each 'cache size' filtered events
 151
 152     /**
 153      * Constructor for the event cache
 154      *
 155      * @param cacheSize
 156      *            The size of the cache, in number of events
 157      * @param table
 158      *            The Events table this cache will cover
 159      */
 160     public TmfEventsCache(int cacheSize, TmfEventsTable table) {
 161         fCacheSize = cacheSize;
 162         fCache = new CachedEvent[cacheSize * 2]; // the cache holds two blocks of cache size
 163         fTable = table;
 164     }
 165
 166     /**
 167      * Assign a new trace to this events cache. This clears the current
 168      * contents.
 169      *
 170      * @param trace
 171      *            The trace to assign.
 172      */
 173     public void setTrace(ITmfTrace trace) {
 174         fTrace = trace;
 175         clear();
 176     }
 177
 178     /**
 179      * Clear the current contents of this cache.
 180      */
 181     public synchronized void clear() {
 182         if (job != null && job.getState() != Job.NONE) {
 183             job.cancel();
 184         }
 185         Arrays.fill(fCache, null);
 186         fCacheStartIndex = 0;
 187         fCacheEndIndex = 0;
 188         fFilterIndex.clear();
 189     }
 190
 191     /**
 192      * Apply a filter on this event cache. This clears the current cache
 193      * contents.
 194      *
 195      * @param filter
 196      *            The ITmfFilter to apply.
 197      */
 198     public void applyFilter(ITmfFilter filter) {
 199         fFilter = filter;
 200         clear();
 201     }
 202
 203     /**
 204      * Clear the current filter on this cache. This also clears the current
 205      * cache contents.
 206      */
 207     public void clearFilter() {
 208         fFilter = null;
 209         clear();
 210     }
 211
 212     /**
 213      * Get an event from the cache. If the cache does not contain the event,
 214      * a cache population request is triggered.
 215      *
 216      * @param index
 217      *            The index of this event in the cache
 218      * @return The cached event, or 'null' if the event is not in the cache
 219      */
 220     public synchronized CachedEvent getEvent(int index) {
 221         if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {
 222             int i = index - fCacheStartIndex;
 223             return fCache[i];
 224         }
 225         populateCache(index);
 226         return null;
 227     }
 228
 229     /**
 230      * Peek an event in the cache. Does not trigger cache population.
 231      *
 232      * @param index
 233      *            Index of the event to peek
 234      * @return The cached event, or 'null' if the event is not in the cache
 235      */
 236     public synchronized CachedEvent peekEvent(int index) {
 237         if ((index >= fCacheStartIndex) && (index < fCacheEndIndex)) {
 238             int i = index - fCacheStartIndex;
 239             return fCache[i];
 240         }
 241         return null;
 242     }
 243
 244     /**
 245      * Add a trace event to the cache.
 246      *
 247      * @param event
 248      *            The original trace event to be cached
 249      * @param rank
 250      *            The rank of this event in the trace
 251      * @param index
 252      *            The index this event will occupy in the cache
 253      */
 254     public synchronized void storeEvent(ITmfEvent event, long rank, int index) {
 255         if (index == fCacheEndIndex) {
 256             int i = index - fCacheStartIndex;
 257             if (i < fCache.length) {
 258                 fCache[i] = new CachedEvent(event, rank);
 259                 fCacheEndIndex++;
 260             }
 261         }
 262         if ((fFilter != null) && ((index % fCacheSize) == 0)) {
 263             int i = index / fCacheSize;
 264             fFilterIndex.add(i, Integer.valueOf((int) rank));
 265         }
 266     }
 267
 268     /**
 269      * Update event repeat count at index
 270      *
 271      * @param index
 272      *            The index this event occupies in the cache
 273      *
 274      * @since 3.2
 275      */
 276     public synchronized void updateCollapsedEvent(int index) {
 277         int i = index - fCacheStartIndex;
 278         if (i < fCache.length) {
 279             fCache[i].repeatCount++;
 280         }
 281     }
 282
 283     /**
 284      * Get the cache index of an event from his rank in the trace. This will
 285      * take in consideration any filter that might be applied.
 286      *
 287      * @param rank
 288      *            The rank of the event in the trace
 289      * @return The position (index) this event should use once cached
 290      */
 291     public int getFilteredEventIndex(final long rank) {
 292         int current;
 293         int startRank;
 294         TmfEventRequest request;
 295         final ITmfFilter filter = fFilter;
 296         synchronized (this) {
 297             int start = 0;
 298             int end = fFilterIndex.size();
 299
 300             if ((fCacheEndIndex - fCacheStartIndex) > 1) {
 301                 if (rank < fCache[0].rank) {
 302                     end = (fCacheStartIndex / fCacheSize) + 1;
 303                 } else if (rank > fCache[fCacheEndIndex - fCacheStartIndex - 1].rank) {
 304                     start = fCacheEndIndex / fCacheSize;
 305                 } else {
 306                     for (int i = 0; i < (fCacheEndIndex - fCacheStartIndex); i++) {
 307                         if (fCache[i].rank >= rank) {
 308                             return fCacheStartIndex + i;
 309                         }
 310                     }
 311                     return fCacheEndIndex;
 312                 }
 313             }
 314
 315             current = (start + end) / 2;
 316             while (current != start) {
 317                 if (rank < fFilterIndex.get(current)) {
 318                     end = current;
 319                     current = (start + end) / 2;
 320                 } else {
 321                     start = current;
 322                     current = (start + end) / 2;
 323                 }
 324             }
 325             startRank = fFilterIndex.size() > 0 ? fFilterIndex.get(current) : 0;
 326         }
 327
 328         final int index = current * fCacheSize;
 329
 330         class DataRequest extends TmfEventRequest {
 331             ITmfFilter requestFilter;
 332             int requestRank;
 333             int requestIndex;
 334
 335             DataRequest(Class<? extends ITmfEvent> dataType, ITmfFilter reqFilter, int start, int nbRequested) {
 336                 super(dataType, TmfTimeRange.ETERNITY, start, nbRequested,
 337                         TmfEventRequest.ExecutionType.FOREGROUND);
 338                 requestFilter = reqFilter;
 339                 requestRank = start;
 340                 requestIndex = index;
 341             }
 342
 343             @Override
 344             public void handleData(ITmfEvent event) {
 345                 super.handleData(event);
 346                 if (isCancelled()) {
 347                     return;
 348                 }
 349                 if (requestRank >= rank) {
 350                     cancel();
 351                     return;
 352                 }
 353                 requestRank++;
 354                 if (requestFilter.matches(event)) {
 355                     requestIndex++;
 356                 }
 357             }
 358
 359             public int getFilteredIndex() {
 360                 return requestIndex;
 361             }
 362         }
 363
 364         request = new DataRequest(ITmfEvent.class, filter, startRank, ITmfEventRequest.ALL_DATA);
 365         ((ITmfEventProvider) fTrace).sendRequest(request);
 366         try {
 367             request.waitForCompletion();
 368             return ((DataRequest) request).getFilteredIndex();
 369         } catch (InterruptedException e) {
 370             Activator.getDefault().logError("Filter request interrupted!", e); //$NON-NLS-1$
 371         }
 372         return 0;
 373     }
 374
 375     // ------------------------------------------------------------------------
 376     // Event cache population
 377     // ------------------------------------------------------------------------
 378
 379     // The event fetching job
 380     private Job job;
 381     private synchronized void populateCache(final int index) {
 382
 383         /* Check if the current job will fetch the requested event:
 384          * 1. The job must exist
 385          * 2. It must be running (i.e. not completed)
 386          * 3. The requested index must be within the cache range
 387          *
 388          * If the job meets these conditions, we simply exit.
 389          * Otherwise, we create a new job but we might have to cancel
 390          * an existing job for an obsolete range.
 391          */
 392         if (job != null) {
 393             if (job.getState() != Job.NONE) {
 394                 if ((index >= fCacheStartIndex) && (index < (fCacheStartIndex + fCache.length))) {
 395                     return;
 396                 }
 397                 // The new index is out of the requested range
 398                 // Kill the job and start a new one
 399                 job.cancel();
 400             }
 401         }
 402
 403         // Populate the cache starting at the index that is one block less
 404         // of cache size than the requested index. The cache will hold two
 405         // consecutive blocks of cache size, centered on the requested index.
 406         fCacheStartIndex = Math.max(0, index - fCacheSize);
 407         fCacheEndIndex   = fCacheStartIndex;
 408
 409         job = new Job("Fetching Events") { //$NON-NLS-1$
 410             private int startIndex = fCacheStartIndex;
 411             private int skipCount = 0;
 412             @Override
 413             protected IStatus run(final IProgressMonitor monitor) {
 414
 415                 int nbRequested;
 416                 if (fFilter == null) {
 417                     nbRequested = fCache.length;
 418                 } else {
 419                     nbRequested = ITmfEventRequest.ALL_DATA;
 420                     int i = startIndex / fCacheSize;
 421                     if (i < fFilterIndex.size()) {
 422                         skipCount = startIndex - (i * fCacheSize);
 423                         startIndex = fFilterIndex.get(i);
 424                     }
 425                 }
 426
 427                 TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
 428                         TmfTimeRange.ETERNITY,
 429                         startIndex,
 430                         nbRequested,
 431                         TmfEventRequest.ExecutionType.FOREGROUND) {
 432                     private int count = 0;
 433                     private long rank = startIndex;
 434                     @Override
 435                     public void handleData(ITmfEvent event) {
 436                         // If the job is canceled, cancel the request so waitForCompletion() will unlock
 437                         if (monitor.isCanceled()) {
 438                             cancel();
 439                             return;
 440                         }
 441                         super.handleData(event);
 442                         if (((fFilter == null) || fFilter.matches(event)) && (skipCount-- <= 0)) {
 443                             synchronized (TmfEventsCache.this) {
 444                                 if (monitor.isCanceled()) {
 445                                     return;
 446                                 }
 447                                 fCache[count] = new CachedEvent(event, rank);
 448                                 count++;
 449                                 fCacheEndIndex++;
 450                             }
 451                             if (fFilter != null) {
 452                                 fTable.cacheUpdated(false);
 453                             }
 454                         } else if (((fFilter != null) && !fFilter.matches(event)) && (skipCount <= 0)) { // TODO fix duplicated call to matches()
 455                             if ((count > 0) && (fFilter instanceof TmfCollapseFilter)) {
 456                                 fCache[count - 1].repeatCount++;
 457                             }
 458                         }
 459                         if (count >= fCache.length) {
 460                             cancel();
 461                         } else if ((fFilter != null) && (count >= (fTable.getTable().getItemCount() - 3))) { // -1 for header row, -2 for top and bottom filter status rows
 462                             cancel();
 463                         }
 464                         rank++;
 465                     }
 466                 };
 467
 468                 ((ITmfEventProvider) fTrace).sendRequest(request);
 469                 try {
 470                     request.waitForCompletion();
 471                 } catch (InterruptedException e) {
 472                     Activator.getDefault().logError("Wait for completion interrupted for populateCache ", e); //$NON-NLS-1$
 473                 }
 474
 475                 fTable.cacheUpdated(true);
 476
 477                 // Flag the UI thread that the cache is ready
 478                 if (monitor.isCanceled()) {
 479                     return Status.CANCEL_STATUS;
 480                 }
 481                 return Status.OK_STATUS;
 482             }
 483         };
 484         //job.setSystem(true);
 485         job.setPriority(Job.SHORT);
 486         job.schedule();
 487     }
 488
 489 }