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