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