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