analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/analysis/timing/ui/views/segmentstore/scatter/AbstractSegmentStoreScatterGraphViewer.java

   1 /******************************************************************************
   2  * Copyright (c) 2015, 2016 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  *   France Lapointe Nguyen - Initial API and implementation
  11  *   Bernd Hufmann - Extracted abstract class from LatencyScatterGraphViewer
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.scatter;
  15
  16 import java.text.Format;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.Collections;
  20 import java.util.Iterator;
  21 import java.util.List;
  22 import java.util.concurrent.atomic.AtomicInteger;
  23
  24 import org.eclipse.core.runtime.IProgressMonitor;
  25 import org.eclipse.core.runtime.IStatus;
  26 import org.eclipse.core.runtime.Status;
  27 import org.eclipse.core.runtime.jobs.Job;
  28 import org.eclipse.jdt.annotation.Nullable;
  29 import org.eclipse.swt.widgets.Composite;
  30 import org.eclipse.swt.widgets.Display;
  31 import org.eclipse.tracecompass.analysis.timing.core.segmentstore.IAnalysisProgressListener;
  32 import org.eclipse.tracecompass.analysis.timing.core.segmentstore.ISegmentStoreProvider;
  33 import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.SubSecondTimeWithUnitFormat;
  34 import org.eclipse.tracecompass.internal.analysis.timing.ui.Activator;
  35 import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.scatter.Messages;
  36 import org.eclipse.tracecompass.internal.analysis.timing.ui.views.segmentstore.scatter.SegmentStoreScatterGraphTooltipProvider;
  37 import org.eclipse.tracecompass.segmentstore.core.ISegment;
  38 import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
  39 import org.eclipse.tracecompass.segmentstore.core.SegmentComparators;
  40 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
  41 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  42 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
  43 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  44 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  45 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  46 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  47 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  48 import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.linecharts.TmfCommonXLineChartViewer;
  49 import org.swtchart.ILineSeries;
  50 import org.swtchart.ILineSeries.PlotSymbolType;
  51 import org.swtchart.ISeries.SeriesType;
  52 import org.swtchart.ISeriesSet;
  53 import org.swtchart.LineStyle;
  54
  55 import com.google.common.primitives.Doubles;
  56
  57 /**
  58  * Displays the segment store provider data in a scatter graph
  59  *
  60  * @author France Lapointe Nguyen
  61  * @author Matthew Khouzam - reduced memory usage
  62  * @since 2.0
  63  */
  64 public abstract class AbstractSegmentStoreScatterGraphViewer extends TmfCommonXLineChartViewer {
  65
  66     private static final Format FORMAT = new SubSecondTimeWithUnitFormat();
  67
  68     private final AtomicInteger fDirty = new AtomicInteger();
  69
  70     private final class CompactingSegmentStoreQuery extends Job {
  71         private static final long MAX_POINTS = 1000;
  72         private final long fStart;
  73         private final long fEnd;
  74
  75         private CompactingSegmentStoreQuery(long start, long end) {
  76             super(Messages.SegmentStoreScatterGraphViewer_compactTitle);
  77             fStart = start;
  78             fEnd = end;
  79         }
  80
  81         @Override
  82         protected IStatus run(@Nullable IProgressMonitor monitor) {
  83             final IProgressMonitor statusMonitor = monitor;
  84             try {
  85                 if (statusMonitor == null) {
  86                     return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Monitor is null"); //$NON-NLS-1$
  87                 }
  88
  89                 ISegmentStoreProvider segmentProvider = getSegmentProvider();
  90                 final long startTime = fStart;
  91                 final long endTime = fEnd;
  92                 if (segmentProvider == null) {
  93                     redraw(statusMonitor, startTime, startTime, Collections.EMPTY_LIST);
  94                     return new Status(IStatus.WARNING, Activator.PLUGIN_ID, "segment provider not available"); //$NON-NLS-1$
  95                 }
  96
  97                 final ISegmentStore<ISegment> segStore = segmentProvider.getSegmentStore();
  98                 if (segStore == null) {
  99                     redraw(statusMonitor, startTime, startTime, Collections.EMPTY_LIST);
 100                     return new Status(IStatus.INFO, Activator.PLUGIN_ID, "Segment provider does not have segments"); //$NON-NLS-1$
 101                 }
 102
 103                 fPixelStart = startTime;
 104                 fPixelSize = Math.max(1, (endTime - startTime) / MAX_POINTS);
 105                 final Iterable<ISegment> intersectingElements = segStore.getIntersectingElements(startTime, endTime);
 106                 final List<ISegment> list = convertIterableToList(intersectingElements, statusMonitor);
 107                 final List<ISegment> displayData = (!list.isEmpty()) ? compactList(startTime, list, statusMonitor) : list;
 108
 109                 redraw(statusMonitor, startTime, endTime, displayData);
 110
 111                 if (statusMonitor.isCanceled()) {
 112                     return Status.CANCEL_STATUS;
 113                 }
 114                 return Status.OK_STATUS;
 115             } finally {
 116                 /*
 117                  * fDirty should have been incremented before creating a job, so
 118                  * we decrement it once the job is done
 119                  */
 120                 fDirty.decrementAndGet();
 121             }
 122
 123         }
 124
 125         private void redraw(final IProgressMonitor statusMonitor, final long startTime, final long endTime, final List<ISegment> displayData) {
 126             fDisplayData = displayData;
 127             /*
 128              * Increment at every redraw, since the content of the view is not
 129              * current
 130              */
 131             fDirty.incrementAndGet();
 132             Display.getDefault().asyncExec(new Runnable() {
 133
 134                 @Override
 135                 public void run() {
 136                     try {
 137                         updateData(startTime, endTime, displayData.size(), statusMonitor);
 138                     } finally {
 139                         /* Decrement once the redraw is done */
 140                         fDirty.decrementAndGet();
 141                     }
 142                 }
 143             });
 144         }
 145
 146         private List<ISegment> compactList(final long startTime, final List<ISegment> listToCompact, final IProgressMonitor statusMonitor) {
 147             List<ISegment> displayData = new ArrayList<>();
 148             ISegment last = listToCompact.get(0);
 149             if (last.getStart() >= startTime) {
 150                 displayData.add(last);
 151             }
 152             for (ISegment next : listToCompact) {
 153                 if (next.getStart() < startTime) {
 154                     continue;
 155                 }
 156                 if (statusMonitor.isCanceled()) {
 157                     return Collections.EMPTY_LIST;
 158                 }
 159                 if (!overlaps(last, next)) {
 160                     displayData.add(next);
 161                     last = next;
 162                 }
 163             }
 164             return displayData;
 165         }
 166
 167         private List<ISegment> convertIterableToList(final Iterable<ISegment> iterable, final IProgressMonitor statusMonitor) {
 168             final List<ISegment> list = new ArrayList<>();
 169             for (ISegment seg : iterable) {
 170                 if (statusMonitor.isCanceled()) {
 171                     return Collections.EMPTY_LIST;
 172                 }
 173                 list.add(seg);
 174             }
 175             Collections.sort(list, SegmentComparators.INTERVAL_START_COMPARATOR);
 176             return list;
 177         }
 178
 179         private boolean overlaps(ISegment last, ISegment next) {
 180             long timePerPix = fPixelSize;
 181             final long start = last.getStart();
 182             final long pixelStart = fPixelStart;
 183             final long pixelDuration = start - pixelStart;
 184             long startPixBoundL = pixelDuration / timePerPix * timePerPix + pixelStart;
 185             long startPixBoundR = startPixBoundL + timePerPix;
 186             final long currentStart = next.getStart();
 187             if (currentStart >= startPixBoundL && currentStart <= startPixBoundR) {
 188                 long length = last.getLength();
 189                 long lengthNext = next.getLength();
 190                 long lengthLow = length / timePerPix * timePerPix;
 191                 long lengthHigh = lengthLow + timePerPix;
 192                 return (lengthNext >= lengthLow && lengthNext <= lengthHigh);
 193             }
 194             return false;
 195         }
 196     }
 197
 198     // ------------------------------------------------------------------------
 199     // Attributes
 200     // ------------------------------------------------------------------------
 201
 202     /**
 203      * Listener to update the model with the segment store provider results once
 204      * its segment store is fully completed
 205      */
 206     private final class SegmentStoreProviderProgressListener implements IAnalysisProgressListener {
 207
 208         @Override
 209         public void onComplete(ISegmentStoreProvider segmentProvider, ISegmentStore<ISegment> segmentStore) {
 210             // Only update the model if trace that was analyzed is active trace
 211             if (segmentProvider.equals(getSegmentProvider())) {
 212                 updateModel(segmentStore);
 213             }
 214         }
 215     }
 216
 217     private long fPixelSize = -1;
 218
 219     private long fPixelStart = 0;
 220     /**
 221      * Data to display
 222      */
 223     private Collection<ISegment> fDisplayData = Collections.EMPTY_LIST;
 224
 225     /**
 226      * Provider completion listener
 227      */
 228     private SegmentStoreProviderProgressListener fListener;
 229
 230     /**
 231      * Current segment provider
 232      */
 233     private @Nullable ISegmentStoreProvider fSegmentProvider;
 234
 235     private @Nullable Job fCompactingJob;
 236
 237     // ------------------------------------------------------------------------
 238     // Constructor
 239     // ------------------------------------------------------------------------
 240
 241     /**
 242      * Constructor
 243      *
 244      * @param parent
 245      *            parent composite
 246      * @param title
 247      *            name of the graph
 248      * @param xLabel
 249      *            name of the x axis
 250      * @param yLabel
 251      *            name of the y axis
 252      */
 253     public AbstractSegmentStoreScatterGraphViewer(Composite parent, String title, String xLabel, String yLabel) {
 254         super(parent, title, xLabel, yLabel);
 255         setTooltipProvider(new SegmentStoreScatterGraphTooltipProvider(this));
 256         fListener = new SegmentStoreProviderProgressListener();
 257         ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
 258         initializeProvider(trace);
 259         getSwtChart().getLegend().setVisible(false);
 260         getSwtChart().getAxisSet().getYAxis(0).getTick().setFormat(FORMAT);
 261     }
 262
 263     private final void initializeProvider(@Nullable ITmfTrace trace) {
 264         if (trace != null) {
 265             final ISegmentStoreProvider segmentStoreProvider = getSegmentStoreProvider(trace);
 266             if (segmentStoreProvider != null) {
 267                 segmentStoreProvider.addListener(fListener);
 268                 setData(segmentStoreProvider);
 269             }
 270         }
 271     }
 272
 273     // ------------------------------------------------------------------------
 274     // Operations
 275     // ------------------------------------------------------------------------
 276
 277     /**
 278      * Update the data in the graph
 279      *
 280      * @param dataInput
 281      *            new model
 282      */
 283     public void updateModel(@Nullable ISegmentStore<ISegment> dataInput) {
 284         // Update new window range
 285         TmfTimeRange currentRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
 286         long currentStart = currentRange.getStartTime().toNanos();
 287         long currentEnd = currentRange.getEndTime().toNanos();
 288         if (dataInput == null) {
 289             if (!getDisplay().isDisposed()) {
 290                 Display.getDefault().syncExec(new Runnable() {
 291                     @Override
 292                     public void run() {
 293                         clearContent();
 294                     }
 295                 });
 296             }
 297             fDisplayData = Collections.EMPTY_LIST;
 298         } else {
 299             Collection<ISegment> elements = (Collection<ISegment>) dataInput.getIntersectingElements(currentStart, currentEnd);
 300             // getIntersectingElements can return an unsorted iterable, make
 301             // sure our collection is sorted
 302             ArrayList<ISegment> list = new ArrayList<>(elements);
 303             Collections.sort(list, SegmentComparators.INTERVAL_START_COMPARATOR);
 304             fDisplayData = list;
 305         }
 306         setWindowRange(currentStart, currentEnd);
 307         updateContent();
 308     }
 309
 310     @Override
 311     protected void initializeDataSource() {
 312         ITmfTrace trace = getTrace();
 313         initializeProvider(trace);
 314         if (trace != null) {
 315             setData(getSegmentStoreProvider(trace));
 316         }
 317     }
 318
 319     @Override
 320     protected void updateData(final long start, final long end, int nb, @Nullable IProgressMonitor monitor) {
 321         // Third parameter is not used by implementation
 322         // Determine data that needs to be visible
 323         Collection<ISegment> data = fDisplayData;
 324
 325         final int dataSize = (nb == 0) ? data.size() : nb;
 326         if (end == start) {
 327             return;
 328         }
 329
 330         List<Double> xSeries = new ArrayList<>(dataSize);
 331         List<Double> ySeries = new ArrayList<>(dataSize);
 332         // For each visible segments, add start time to x value and duration
 333         // for y value
 334         Iterator<ISegment> modelIter = data.iterator();
 335         while (modelIter.hasNext()) {
 336             ISegment segment = modelIter.next();
 337             xSeries.add((double) (segment.getStart() - start));
 338             ySeries.add((double) segment.getLength());
 339         }
 340         setXAxis(Doubles.toArray(xSeries));
 341         setSeries(Messages.SegmentStoreScatterGraphViewer_legend, Doubles.toArray(ySeries));
 342         updateDisplay();
 343     }
 344
 345     @Override
 346     protected void setWindowRange(final long windowStartTime, final long windowEndTime) {
 347         super.setWindowRange(windowStartTime, windowEndTime);
 348     }
 349
 350     @Override
 351     protected ILineSeries addSeries(@Nullable String seriesName) {
 352         ISeriesSet seriesSet = getSwtChart().getSeriesSet();
 353         ILineSeries series = (ILineSeries) seriesSet.createSeries(SeriesType.LINE, seriesName);
 354         series.setVisible(true);
 355         series.enableArea(false);
 356         series.setLineStyle(LineStyle.NONE);
 357         series.setSymbolType(PlotSymbolType.DIAMOND);
 358         return series;
 359     }
 360
 361     /**
 362      * Set the data into the viewer. If the provider is an analysis, it will
 363      * update the model if the analysis is completed or run the analysis if not
 364      * completed
 365      *
 366      * @param provider
 367      *            Segment store provider
 368      */
 369     public void setData(@Nullable ISegmentStoreProvider provider) {
 370         if (provider == null) {
 371             updateModel(null);
 372             return;
 373         }
 374         ISegmentStore<ISegment> segStore = provider.getSegmentStore();
 375         // If results are not null, then segment store is completed and model
 376         // can be updated
 377         if (segStore != null) {
 378             updateModel(segStore);
 379             setSegmentProvider(provider);
 380             return;
 381         }
 382         updateModel(null);
 383         provider.addListener(fListener);
 384         if (provider instanceof IAnalysisModule) {
 385             ((IAnalysisModule) provider).schedule();
 386         }
 387         setSegmentProvider(provider);
 388     }
 389
 390     /**
 391      * Returns the segment store provider
 392      *
 393      * @param trace
 394      *            The trace to consider
 395      * @return the segment store provider
 396      */
 397     protected @Nullable abstract ISegmentStoreProvider getSegmentStoreProvider(ITmfTrace trace);
 398
 399     // ------------------------------------------------------------------------
 400     // Signal handlers
 401     // ------------------------------------------------------------------------
 402
 403     /**
 404      * @param signal
 405      *            Signal received when a different trace is selected
 406      */
 407     @Override
 408     @TmfSignalHandler
 409     public void traceSelected(@Nullable TmfTraceSelectedSignal signal) {
 410         super.traceSelected(signal);
 411         if (signal == null) {
 412             return;
 413         }
 414         ITmfTrace trace = signal.getTrace();
 415         setTrace(trace);
 416         if (trace != null) {
 417             final TmfTimeRange timeRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
 418             setWindowRange(
 419                     timeRange.getStartTime().toNanos(),
 420                     timeRange.getEndTime().toNanos());
 421             setData(getSegmentStoreProvider(trace));
 422             updateContent();
 423         }
 424     }
 425
 426     /**
 427      * @param signal
 428      *            Signal received when trace is opened
 429      */
 430     @Override
 431     @TmfSignalHandler
 432     public void traceOpened(@Nullable TmfTraceOpenedSignal signal) {
 433         super.traceOpened(signal);
 434         if (signal == null) {
 435             return;
 436         }
 437         ITmfTrace trace = signal.getTrace();
 438         setTrace(trace);
 439         if (trace != null) {
 440
 441             final ISegmentStoreProvider segmentStoreProvider = getSegmentStoreProvider(trace);
 442             final TmfTimeRange timeRange = TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange();
 443             setWindowRange(
 444                     timeRange.getStartTime().toNanos(),
 445                     timeRange.getEndTime().toNanos());
 446             setData(segmentStoreProvider);
 447         }
 448
 449     }
 450
 451     @Override
 452     protected void updateContent() {
 453         /*
 454          * Update is requested, content is not up to date, fDirty will be
 455          * decremented in the compacting job
 456          */
 457         fDirty.incrementAndGet();
 458         Job compactingJob = fCompactingJob;
 459         if (compactingJob != null && compactingJob.getState() == Job.RUNNING) {
 460             compactingJob.cancel();
 461         }
 462         compactingJob = new CompactingSegmentStoreQuery(getWindowStartTime(), getWindowEndTime());
 463         fCompactingJob = compactingJob;
 464         compactingJob.schedule();
 465     }
 466
 467     /**
 468      * @param signal
 469      *            Signal received when last opened trace is closed
 470      */
 471     @Override
 472     @TmfSignalHandler
 473     public void traceClosed(@Nullable TmfTraceClosedSignal signal) {
 474         super.traceClosed(signal);
 475         if (signal != null) {
 476             // Check if there is no more opened trace
 477             if (TmfTraceManager.getInstance().getActiveTrace() == null) {
 478                 ISegmentStoreProvider provider = getSegmentProvider();
 479                 if (provider != null) {
 480                     provider.removeListener(fListener);
 481                 }
 482                 clearContent();
 483             }
 484         }
 485         refresh();
 486     }
 487
 488     private @Nullable ISegmentStoreProvider getSegmentProvider() {
 489         return fSegmentProvider;
 490     }
 491
 492     private void setSegmentProvider(ISegmentStoreProvider provider) {
 493         fSegmentProvider = provider;
 494     }
 495
 496     @Override
 497     public boolean isDirty() {
 498         /* Check the parent's or this view's own dirtiness */
 499         return super.isDirty() || (fDirty.get() != 0);
 500     }
 501 }