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

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