org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/resources/ResourcesView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012 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  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.resources;
  14
  15 import java.util.ArrayList;
  16 import java.util.Arrays;
  17 import java.util.Comparator;
  18 import java.util.HashMap;
  19 import java.util.Iterator;
  20 import java.util.List;
  21
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.core.runtime.NullProgressMonitor;
  24 import org.eclipse.jface.action.Action;
  25 import org.eclipse.jface.action.IToolBarManager;
  26 import org.eclipse.jface.action.Separator;
  27 import org.eclipse.linuxtools.internal.lttng2.kernel.core.Attributes;
  28 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;
  29 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.resources.ResourcesEntry.Type;
  30 import org.eclipse.linuxtools.lttng2.kernel.core.trace.CtfKernelTrace;
  31 import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp;
  32 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  33 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  34 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  35 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  36 import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
  37 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  38 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  39 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  40 import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
  41 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  42 import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
  43 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
  44 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  45 import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
  46 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  47 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  48 import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
  49 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  50 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
  51 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  52 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
  53 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  54 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphViewer;
  55 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  56 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  57 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;
  58 import org.eclipse.swt.SWT;
  59 import org.eclipse.swt.widgets.Composite;
  60 import org.eclipse.swt.widgets.Display;
  61 import org.eclipse.ui.IActionBars;
  62 import org.eclipse.ui.IEditorPart;
  63 import org.eclipse.ui.PlatformUI;
  64
  65 /**
  66  * Main implementation for the LTTng 2.0 kernel Resource view
  67  *
  68  * @author Patrick Tasse
  69  */
  70 public class ResourcesView extends TmfView {
  71
  72     // ------------------------------------------------------------------------
  73     // Constants
  74     // ------------------------------------------------------------------------
  75
  76     /** View ID. */
  77     public static final String ID = "org.eclipse.linuxtools.lttng2.kernel.ui.views.resources"; //$NON-NLS-1$
  78
  79     /** Initial time range */
  80     private static final long INITIAL_WINDOW_OFFSET = (1L * 100  * 1000 * 1000); // .1sec
  81
  82     /**
  83      * Redraw state enum
  84      */
  85     private enum State { IDLE, BUSY, PENDING }
  86
  87     // ------------------------------------------------------------------------
  88     // Fields
  89     // ------------------------------------------------------------------------
  90
  91     // The time graph viewer
  92     TimeGraphViewer fTimeGraphViewer;
  93
  94     // The selected trace
  95     private ITmfTrace fTrace;
  96
  97     // The time graph entry list
  98     private ArrayList<TraceEntry> fEntryList;
  99
 100     // The trace to entry list hash map
 101     final private HashMap<ITmfTrace, ArrayList<TraceEntry>> fEntryListMap = new HashMap<ITmfTrace, ArrayList<TraceEntry>>();
 102
 103     // The trace to build thread hash map
 104     final private HashMap<ITmfTrace, BuildThread> fBuildThreadMap = new HashMap<ITmfTrace, BuildThread>();
 105
 106     // The start time
 107     private long fStartTime;
 108
 109     // The end time
 110     private long fEndTime;
 111
 112     // The display width
 113     private final int fDisplayWidth;
 114
 115     // The next resource action
 116     private Action fNextResourceAction;
 117
 118     // The previous resource action
 119     private Action fPreviousResourceAction;
 120
 121     // The zoom thread
 122     private ZoomThread fZoomThread;
 123
 124     // The redraw state used to prevent unnecessary queuing of display runnables
 125     private State fRedrawState = State.IDLE;
 126
 127     // The redraw synchronization object
 128     final private Object fSyncObj = new Object();
 129
 130     // ------------------------------------------------------------------------
 131     // Classes
 132     // ------------------------------------------------------------------------
 133
 134     private class TraceEntry implements ITimeGraphEntry {
 135         // The Trace
 136         private final CtfKernelTrace fKernelTrace;
 137         // The start time
 138         private final long fTraceStartTime;
 139         // The end time
 140         private final long fTraceEndTime;
 141         // The children of the entry
 142         private final ArrayList<ResourcesEntry> fChildren;
 143         // The name of entry
 144         private final String fName;
 145
 146         public TraceEntry(CtfKernelTrace trace, String name, long startTime, long endTime) {
 147             fKernelTrace = trace;
 148             fChildren = new ArrayList<ResourcesEntry>();
 149             fName = name;
 150             fTraceStartTime = startTime;
 151             fTraceEndTime = endTime;
 152         }
 153
 154         @Override
 155         public ITimeGraphEntry getParent() {
 156             return null;
 157         }
 158
 159         @Override
 160         public boolean hasChildren() {
 161             return fChildren != null && fChildren.size() > 0;
 162         }
 163
 164         @Override
 165         public List<ResourcesEntry> getChildren() {
 166             return fChildren;
 167         }
 168
 169         @Override
 170         public String getName() {
 171             return fName;
 172         }
 173
 174         @Override
 175         public long getStartTime() {
 176             return fTraceStartTime;
 177         }
 178
 179         @Override
 180         public long getEndTime() {
 181             return fTraceEndTime;
 182         }
 183
 184         @Override
 185         public boolean hasTimeEvents() {
 186             return false;
 187         }
 188
 189         @Override
 190         public Iterator<ITimeEvent> getTimeEventsIterator() {
 191             return null;
 192         }
 193
 194         @Override
 195         public <T extends ITimeEvent> Iterator<T> getTimeEventsIterator(long startTime, long stopTime, long visibleDuration) {
 196             return null;
 197         }
 198
 199         public CtfKernelTrace getTrace() {
 200             return fKernelTrace;
 201         }
 202
 203         public void addChild(ResourcesEntry entry) {
 204             int index;
 205             for (index = 0; index < fChildren.size(); index++) {
 206                 ResourcesEntry other = fChildren.get(index);
 207                 if (entry.getType().compareTo(other.getType()) < 0) {
 208                     break;
 209                 } else if (entry.getType().equals(other.getType())) {
 210                     if (entry.getId() < other.getId()) {
 211                         break;
 212                     }
 213                 }
 214             }
 215             entry.setParent(this);
 216             fChildren.add(index, entry);
 217         }
 218     }
 219
 220     private static class TraceEntryComparator implements Comparator<ITimeGraphEntry> {
 221         @Override
 222         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 223             int result = o1.getStartTime() < o2.getStartTime() ? -1 : o1.getStartTime() > o2.getStartTime() ? 1 : 0;
 224             if (result == 0) {
 225                 result = o1.getName().compareTo(o2.getName());
 226             }
 227             return result;
 228         }
 229     }
 230
 231     private class BuildThread extends Thread {
 232         private final ITmfTrace fBuildTrace;
 233         private final IProgressMonitor fMonitor;
 234
 235         public BuildThread(ITmfTrace trace) {
 236             super("ResourcesView build"); //$NON-NLS-1$
 237             fBuildTrace = trace;
 238             fMonitor = new NullProgressMonitor();
 239         }
 240
 241         @Override
 242         public void run() {
 243             buildEventList(fBuildTrace, fMonitor);
 244             synchronized (fBuildThreadMap) {
 245                 fBuildThreadMap.remove(this);
 246             }
 247         }
 248
 249         public void cancel() {
 250             fMonitor.setCanceled(true);
 251         }
 252     }
 253
 254     private class ZoomThread extends Thread {
 255         private final ArrayList<TraceEntry> fZoomEntryList;
 256         private final long fZoomStartTime;
 257         private final long fZoomEndTime;
 258         private final IProgressMonitor fMonitor;
 259
 260         public ZoomThread(ArrayList<TraceEntry> entryList, long startTime, long endTime) {
 261             super("ResourcesView zoom"); //$NON-NLS-1$
 262             fZoomEntryList = entryList;
 263             fZoomStartTime = startTime;
 264             fZoomEndTime = endTime;
 265             fMonitor = new NullProgressMonitor();
 266         }
 267
 268         @Override
 269         public void run() {
 270             if (fZoomEntryList == null) {
 271                 return;
 272             }
 273             long resolution = Math.max(1, (fZoomEndTime - fZoomStartTime) / fDisplayWidth);
 274             for (TraceEntry traceEntry : fZoomEntryList) {
 275                 if (!traceEntry.fKernelTrace.getStateSystem().waitUntilBuilt()) {
 276                     return;
 277                 }
 278                 for (ITimeGraphEntry child : traceEntry.getChildren()) {
 279                     if (fMonitor.isCanceled()) {
 280                         break;
 281                     }
 282                     ResourcesEntry entry = (ResourcesEntry) child;
 283                     if (fZoomStartTime <= fStartTime && fZoomEndTime >= fEndTime) {
 284                         entry.setZoomedEventList(null);
 285                     } else {
 286                         List<ITimeEvent> zoomedEventList = getEventList(entry, fZoomStartTime, fZoomEndTime, resolution, true, fMonitor);
 287                         if (zoomedEventList != null) {
 288                             entry.setZoomedEventList(zoomedEventList);
 289                         }
 290                     }
 291                     redraw();
 292                 }
 293             }
 294         }
 295
 296         public void cancel() {
 297             fMonitor.setCanceled(true);
 298         }
 299     }
 300
 301     // ------------------------------------------------------------------------
 302     // Constructors
 303     // ------------------------------------------------------------------------
 304
 305     /**
 306      * Default constructor
 307      */
 308     public ResourcesView() {
 309         super(ID);
 310         fDisplayWidth = Display.getDefault().getBounds().width;
 311     }
 312
 313     // ------------------------------------------------------------------------
 314     // ViewPart
 315     // ------------------------------------------------------------------------
 316
 317     /* (non-Javadoc)
 318      * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)
 319      */
 320     @Override
 321     public void createPartControl(Composite parent) {
 322         fTimeGraphViewer = new TimeGraphViewer(parent, SWT.NONE);
 323
 324         fTimeGraphViewer.setTimeGraphProvider(new ResourcesPresentationProvider());
 325
 326         fTimeGraphViewer.setTimeCalendarFormat(true);
 327
 328         fTimeGraphViewer.addRangeListener(new ITimeGraphRangeListener() {
 329             @Override
 330             public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 331                 long startTime = event.getStartTime();
 332                 long endTime = event.getEndTime();
 333                 TmfTimeRange range = new TmfTimeRange(new CtfTmfTimestamp(startTime), new CtfTmfTimestamp(endTime));
 334                 TmfTimestamp time = new CtfTmfTimestamp(fTimeGraphViewer.getSelectedTime());
 335                 broadcast(new TmfRangeSynchSignal(ResourcesView.this, range, time));
 336                 startZoomThread(startTime, endTime);
 337             }
 338         });
 339
 340         fTimeGraphViewer.addTimeListener(new ITimeGraphTimeListener() {
 341             @Override
 342             public void timeSelected(TimeGraphTimeEvent event) {
 343                 long time = event.getTime();
 344                 broadcast(new TmfTimeSynchSignal(ResourcesView.this, new CtfTmfTimestamp(time)));
 345             }
 346         });
 347
 348         // View Action Handling
 349         makeActions();
 350         contributeToActionBars();
 351
 352         IEditorPart editor = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
 353         if (editor instanceof ITmfTraceEditor) {
 354             ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
 355             if (trace != null) {
 356                 traceSelected(new TmfTraceSelectedSignal(this, trace));
 357             }
 358         }
 359     }
 360
 361     /* (non-Javadoc)
 362      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 363      */
 364     @Override
 365     public void setFocus() {
 366         fTimeGraphViewer.setFocus();
 367     }
 368
 369     // ------------------------------------------------------------------------
 370     // Signal handlers
 371     // ------------------------------------------------------------------------
 372
 373     /**
 374      * Handler for the trace selected signal
 375      *
 376      * @param signal
 377      *            The incoming signal
 378      */
 379     @TmfSignalHandler
 380     public void traceSelected(final TmfTraceSelectedSignal signal) {
 381         if (signal.getTrace() == fTrace) {
 382             return;
 383         }
 384         fTrace = signal.getTrace();
 385
 386         synchronized (fEntryListMap) {
 387             fEntryList = fEntryListMap.get(fTrace);
 388             if (fEntryList == null) {
 389                 synchronized (fBuildThreadMap) {
 390                     BuildThread buildThread = new BuildThread(fTrace);
 391                     fBuildThreadMap.put(fTrace, buildThread);
 392                     buildThread.start();
 393                 }
 394             } else {
 395                 fStartTime = fTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 396                 fEndTime = fTrace.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 397                 refresh(INITIAL_WINDOW_OFFSET);
 398             }
 399         }
 400     }
 401
 402     /**
 403      * Trace is disposed: clear the data structures and the view
 404      *
 405      * @param signal the signal received
 406      */
 407     @TmfSignalHandler
 408     public void traceClosed(final TmfTraceClosedSignal signal) {
 409         synchronized (fBuildThreadMap) {
 410             BuildThread buildThread = fBuildThreadMap.remove(signal.getTrace());
 411             if (buildThread != null) {
 412                 buildThread.cancel();
 413             }
 414         }
 415         synchronized (fEntryListMap) {
 416             fEntryListMap.remove(signal.getTrace());
 417         }
 418         if (signal.getTrace() == fTrace) {
 419             fTrace = null;
 420             fStartTime = 0;
 421             fEndTime = 0;
 422             if (fZoomThread != null) {
 423                 fZoomThread.cancel();
 424             }
 425             refresh(INITIAL_WINDOW_OFFSET);
 426         }
 427     }
 428
 429     /**
 430      * Handler for the TimeSynch signal
 431      *
 432      * @param signal
 433      *            The incoming signal
 434      */
 435     @TmfSignalHandler
 436     public void synchToTime(final TmfTimeSynchSignal signal) {
 437         if (signal.getSource() == this || fTrace == null) {
 438             return;
 439         }
 440         final long time = signal.getCurrentTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 441         Display.getDefault().asyncExec(new Runnable() {
 442             @Override
 443             public void run() {
 444                 if (fTimeGraphViewer.getControl().isDisposed()) {
 445                     return;
 446                 }
 447                 fTimeGraphViewer.setSelectedTime(time, true);
 448                 startZoomThread(fTimeGraphViewer.getTime0(), fTimeGraphViewer.getTime1());
 449             }
 450         });
 451     }
 452
 453     /**
 454      * Handler for the RangeSynch signal
 455      *
 456      * @param signal
 457      *            The incoming signal
 458      */
 459     @TmfSignalHandler
 460     public void synchToRange(final TmfRangeSynchSignal signal) {
 461         if (signal.getSource() == this || fTrace == null) {
 462             return;
 463         }
 464         final long startTime = signal.getCurrentRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 465         final long endTime = signal.getCurrentRange().getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 466         final long time = signal.getCurrentTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 467         Display.getDefault().asyncExec(new Runnable() {
 468             @Override
 469             public void run() {
 470                 if (fTimeGraphViewer.getControl().isDisposed()) {
 471                     return;
 472                 }
 473                 fTimeGraphViewer.setStartFinishTime(startTime, endTime);
 474                 fTimeGraphViewer.setSelectedTime(time, false);
 475                 startZoomThread(startTime, endTime);
 476             }
 477         });
 478     }
 479
 480     // ------------------------------------------------------------------------
 481     // Internal
 482     // ------------------------------------------------------------------------
 483
 484     private void buildEventList(final ITmfTrace trace, IProgressMonitor monitor) {
 485         fStartTime = Long.MAX_VALUE;
 486         fEndTime = Long.MIN_VALUE;
 487         ITmfTrace[] traces;
 488         if (trace instanceof TmfExperiment) {
 489             TmfExperiment experiment = (TmfExperiment) trace;
 490             traces = experiment.getTraces();
 491         } else {
 492             traces = new ITmfTrace[] { trace };
 493         }
 494         ArrayList<TraceEntry> entryList = new ArrayList<TraceEntry>();
 495         for (ITmfTrace aTrace : traces) {
 496             if (monitor.isCanceled()) {
 497                 return;
 498             }
 499             if (aTrace instanceof CtfKernelTrace) {
 500                 CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) aTrace;
 501                 ITmfStateSystem ssq = ctfKernelTrace.getStateSystem();
 502                 if (!ssq.waitUntilBuilt()) {
 503                     return;
 504                 }
 505                 long startTime = ssq.getStartTime();
 506                 long endTime = ssq.getCurrentEndTime() + 1;
 507                 TraceEntry groupEntry = new TraceEntry(ctfKernelTrace, aTrace.getName(), startTime, endTime);
 508                 entryList.add(groupEntry);
 509                 fStartTime = Math.min(fStartTime, startTime);
 510                 fEndTime = Math.max(fEndTime, endTime);
 511                 List<Integer> cpuQuarks = ssq.getQuarks(Attributes.CPUS, "*"); //$NON-NLS-1$
 512                 ResourcesEntry[] cpuEntries = new ResourcesEntry[cpuQuarks.size()];
 513                 for (int i = 0; i < cpuQuarks.size(); i++) {
 514                     int cpuQuark = cpuQuarks.get(i);
 515                     int cpu = Integer.parseInt(ssq.getAttributeName(cpuQuark));
 516                     ResourcesEntry entry = new ResourcesEntry(cpuQuark, ctfKernelTrace, Type.CPU, cpu);
 517                     groupEntry.addChild(entry);
 518                     cpuEntries[i] = entry;
 519                 }
 520                 List<Integer> irqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.IRQS, "*"); //$NON-NLS-1$
 521                 ResourcesEntry[] irqEntries = new ResourcesEntry[irqQuarks.size()];
 522                 for (int i = 0; i < irqQuarks.size(); i++) {
 523                     int irqQuark = irqQuarks.get(i);
 524                     int irq = Integer.parseInt(ssq.getAttributeName(irqQuark));
 525                     ResourcesEntry entry = new ResourcesEntry(irqQuark, ctfKernelTrace, Type.IRQ, irq);
 526                     groupEntry.addChild(entry);
 527                     irqEntries[i] = entry;
 528                 }
 529                 List<Integer> softIrqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.SOFT_IRQS, "*"); //$NON-NLS-1$
 530                 ResourcesEntry[] softIrqEntries = new ResourcesEntry[softIrqQuarks.size()];
 531                 for (int i = 0; i < softIrqQuarks.size(); i++) {
 532                     int softIrqQuark = softIrqQuarks.get(i);
 533                     int softIrq = Integer.parseInt(ssq.getAttributeName(softIrqQuark));
 534                     ResourcesEntry entry = new ResourcesEntry(softIrqQuark, ctfKernelTrace, Type.SOFT_IRQ, softIrq);
 535                     groupEntry.addChild(entry);
 536                     softIrqEntries[i] = entry;
 537                 }
 538             }
 539         }
 540         synchronized (fEntryListMap) {
 541             fEntryListMap.put(trace, (ArrayList<TraceEntry>) entryList.clone());
 542         }
 543         if (trace == fTrace) {
 544             refresh(INITIAL_WINDOW_OFFSET);
 545         }
 546         for (TraceEntry traceEntry : entryList) {
 547             if (monitor.isCanceled()) {
 548                 return;
 549             }
 550             CtfKernelTrace ctfKernelTrace = traceEntry.getTrace();
 551             ITmfStateSystem ssq = ctfKernelTrace.getStateSystem();
 552             long startTime = ssq.getStartTime();
 553             long endTime = ssq.getCurrentEndTime() + 1;
 554             long resolution = (endTime - startTime) / fDisplayWidth;
 555             for (ResourcesEntry entry : traceEntry.getChildren()) {
 556                 List<ITimeEvent> eventList = getEventList(entry, startTime, endTime, resolution, false, monitor);
 557                 entry.setEventList(eventList);
 558                 redraw();
 559             }
 560         }
 561     }
 562
 563     private static List<ITimeEvent> getEventList(ResourcesEntry entry,
 564             long startTime, long endTime, long resolution, boolean includeNull,
 565             IProgressMonitor monitor) {
 566         ITmfStateSystem ssq = entry.getTrace().getStateSystem();
 567         startTime = Math.max(startTime, ssq.getStartTime());
 568         endTime = Math.min(endTime, ssq.getCurrentEndTime() + 1);
 569         if (endTime <= startTime) {
 570             return null;
 571         }
 572         List<ITimeEvent> eventList = null;
 573         int quark = entry.getQuark();
 574         try {
 575             if (entry.getType().equals(Type.CPU)) {
 576                 int statusQuark = ssq.getQuarkRelative(quark, Attributes.STATUS);
 577                 List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, startTime, endTime - 1, resolution, monitor);
 578                 eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
 579                 long lastEndTime = -1;
 580                 for (ITmfStateInterval statusInterval : statusIntervals) {
 581                     if (monitor.isCanceled()) {
 582                         return null;
 583                     }
 584                     int status = statusInterval.getStateValue().unboxInt();
 585                     long time = statusInterval.getStartTime();
 586                     long duration = statusInterval.getEndTime() - time + 1;
 587                     if (!statusInterval.getStateValue().isNull()) {
 588                         if (lastEndTime != time && lastEndTime != -1) {
 589                             eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));
 590                         }
 591                         eventList.add(new ResourcesEvent(entry, time, duration, status));
 592                         lastEndTime = time + duration;
 593                     } else {
 594                         if (includeNull) {
 595                             eventList.add(new ResourcesEvent(entry, time, duration));
 596                         }
 597                     }
 598                 }
 599             } else if (entry.getType().equals(Type.IRQ)) {
 600                 List<ITmfStateInterval> irqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution, monitor);
 601                 eventList = new ArrayList<ITimeEvent>(irqIntervals.size());
 602                 long lastEndTime = -1;
 603                 boolean lastIsNull = true;
 604                 for (ITmfStateInterval irqInterval : irqIntervals) {
 605                     if (monitor.isCanceled()) {
 606                         return null;
 607                     }
 608                     long time = irqInterval.getStartTime();
 609                     long duration = irqInterval.getEndTime() - time + 1;
 610                     if (!irqInterval.getStateValue().isNull()) {
 611                         int cpu = irqInterval.getStateValue().unboxInt();
 612                         eventList.add(new ResourcesEvent(entry, time, duration, cpu));
 613                         lastIsNull = false;
 614                     } else {
 615                         if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {
 616                             eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));
 617                         }
 618                         if (includeNull) {
 619                             eventList.add(new ResourcesEvent(entry, time, duration));
 620                         }
 621                         lastIsNull = true;
 622                     }
 623                     lastEndTime = time + duration;
 624                 }
 625             } else if (entry.getType().equals(Type.SOFT_IRQ)) {
 626                 List<ITmfStateInterval> softIrqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution, monitor);
 627                 eventList = new ArrayList<ITimeEvent>(softIrqIntervals.size());
 628                 long lastEndTime = -1;
 629                 boolean lastIsNull = true;
 630                 for (ITmfStateInterval softIrqInterval : softIrqIntervals) {
 631                     if (monitor.isCanceled()) {
 632                         return null;
 633                     }
 634                     long time = softIrqInterval.getStartTime();
 635                     long duration = softIrqInterval.getEndTime() - time + 1;
 636                     if (!softIrqInterval.getStateValue().isNull()) {
 637                         int cpu = softIrqInterval.getStateValue().unboxInt();
 638                         eventList.add(new ResourcesEvent(entry, time, duration, cpu));
 639                     } else {
 640                         if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {
 641                             eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));
 642                         }
 643                         if (includeNull) {
 644                             eventList.add(new ResourcesEvent(entry, time, duration));
 645                         }
 646                         lastIsNull = true;
 647                     }
 648                     lastEndTime = time + duration;
 649                 }
 650             }
 651         } catch (AttributeNotFoundException e) {
 652             e.printStackTrace();
 653         } catch (TimeRangeException e) {
 654             e.printStackTrace();
 655         } catch (StateValueTypeException e) {
 656             e.printStackTrace();
 657         } catch (StateSystemDisposedException e) {
 658             /* Ignored */
 659         }
 660         return eventList;
 661     }
 662
 663     private void refresh(final long windowRange) {
 664         Display.getDefault().asyncExec(new Runnable() {
 665             @Override
 666             public void run() {
 667                 if (fTimeGraphViewer.getControl().isDisposed()) {
 668                     return;
 669                 }
 670                 ITimeGraphEntry[] entries = null;
 671                 synchronized (fEntryListMap) {
 672                     fEntryList = fEntryListMap.get(fTrace);
 673                     if (fEntryList == null) {
 674                         fEntryList = new ArrayList<TraceEntry>();
 675                     }
 676                     entries = fEntryList.toArray(new ITimeGraphEntry[0]);
 677                 }
 678                 if (entries != null) {
 679                     Arrays.sort(entries, new TraceEntryComparator());
 680                     fTimeGraphViewer.setInput(entries);
 681                     fTimeGraphViewer.setTimeBounds(fStartTime, fEndTime);
 682
 683                     long endTime = fStartTime + windowRange;
 684
 685                     if (fEndTime < endTime) {
 686                         endTime = fEndTime;
 687                     }
 688                     fTimeGraphViewer.setStartFinishTime(fStartTime, endTime);
 689
 690                     startZoomThread(fStartTime, endTime);
 691                 }
 692             }
 693         });
 694     }
 695
 696     private void redraw() {
 697         synchronized (fSyncObj) {
 698             if (fRedrawState == State.IDLE) {
 699                 fRedrawState = State.BUSY;
 700             } else {
 701                 fRedrawState = State.PENDING;
 702                 return;
 703             }
 704         }
 705         Display.getDefault().asyncExec(new Runnable() {
 706             @Override
 707             public void run() {
 708                 if (fTimeGraphViewer.getControl().isDisposed()) {
 709                     return;
 710                 }
 711                 fTimeGraphViewer.getControl().redraw();
 712                 fTimeGraphViewer.getControl().update();
 713                 synchronized (fSyncObj) {
 714                     if (fRedrawState == State.PENDING) {
 715                         fRedrawState = State.IDLE;
 716                         redraw();
 717                     } else {
 718                         fRedrawState = State.IDLE;
 719                     }
 720                 }
 721             }
 722         });
 723     }
 724
 725     private void startZoomThread(long startTime, long endTime) {
 726         if (fZoomThread != null) {
 727             fZoomThread.cancel();
 728         }
 729         fZoomThread = new ZoomThread(fEntryList, startTime, endTime);
 730         fZoomThread.start();
 731     }
 732
 733     private void makeActions() {
 734         fPreviousResourceAction = fTimeGraphViewer.getPreviousItemAction();
 735         fPreviousResourceAction.setText(Messages.ResourcesView_previousResourceActionNameText);
 736         fPreviousResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);
 737         fNextResourceAction = fTimeGraphViewer.getNextItemAction();
 738         fNextResourceAction.setText(Messages.ResourcesView_nextResourceActionNameText);
 739         fNextResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);
 740     }
 741
 742     private void contributeToActionBars() {
 743         IActionBars bars = getViewSite().getActionBars();
 744         fillLocalToolBar(bars.getToolBarManager());
 745     }
 746
 747     private void fillLocalToolBar(IToolBarManager manager) {
 748         manager.add(fTimeGraphViewer.getShowLegendAction());
 749         manager.add(new Separator());
 750         manager.add(fTimeGraphViewer.getResetScaleAction());
 751         manager.add(fTimeGraphViewer.getPreviousEventAction());
 752         manager.add(fTimeGraphViewer.getNextEventAction());
 753         manager.add(fPreviousResourceAction);
 754         manager.add(fNextResourceAction);
 755         manager.add(fTimeGraphViewer.getZoomInAction());
 756         manager.add(fTimeGraphViewer.getZoomOutAction());
 757         manager.add(new Separator());
 758     }
 759 }