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