org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/controlflow/ControlFlowView.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.controlflow;
  14
  15 import java.util.ArrayList;
  16 import java.util.Arrays;
  17 import java.util.List;
  18
  19 import org.eclipse.core.runtime.IProgressMonitor;
  20 import org.eclipse.core.runtime.NullProgressMonitor;
  21 import org.eclipse.jface.action.Action;
  22 import org.eclipse.jface.action.IToolBarManager;
  23 import org.eclipse.jface.action.Separator;
  24 import org.eclipse.jface.viewers.ILabelProviderListener;
  25 import org.eclipse.jface.viewers.ITableLabelProvider;
  26 import org.eclipse.jface.viewers.ITreeContentProvider;
  27 import org.eclipse.jface.viewers.Viewer;
  28 import org.eclipse.linuxtools.internal.lttng2.kernel.core.Attributes;
  29 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;
  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.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.TmfTimeSynchSignal;
  43 import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier;
  44 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  45 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  46 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  47 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
  48 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
  49 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  50 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphCombo;
  51 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
  52 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;
  53 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  54 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  55 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  56 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;
  57 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils;
  58 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.Resolution;
  59 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
  60 import org.eclipse.swt.SWT;
  61 import org.eclipse.swt.graphics.Image;
  62 import org.eclipse.swt.widgets.Composite;
  63 import org.eclipse.swt.widgets.Display;
  64 import org.eclipse.swt.widgets.TreeColumn;
  65 import org.eclipse.ui.IActionBars;
  66
  67 public class ControlFlowView extends TmfView {
  68
  69     // ------------------------------------------------------------------------
  70     // Constants
  71     // ------------------------------------------------------------------------
  72
  73     /**
  74      * View ID.
  75      */
  76     public static final String ID = "org.eclipse.linuxtools.lttng2.kernel.ui.views.controlflow"; //$NON-NLS-1$
  77
  78     /**
  79      * Initial time range
  80      */
  81     private static final long INITIAL_WINDOW_OFFSET = (1L * 100  * 1000 * 1000); // .1sec
  82
  83     private static final String PROCESS_COLUMN    = Messages.ControlFlowView_processColumn;
  84     private static final String TID_COLUMN        = Messages.ControlFlowView_tidColumn;
  85     private static final String PTID_COLUMN       = Messages.ControlFlowView_ptidColumn;
  86     private static final String BIRTH_TIME_COLUMN = Messages.ControlFlowView_birthTimeColumn;
  87     private static final String TRACE_COLUMN      = Messages.ControlFlowView_traceColumn;
  88
  89     private final String[] COLUMN_NAMES = new String[] {
  90             PROCESS_COLUMN,
  91             TID_COLUMN,
  92             PTID_COLUMN,
  93             BIRTH_TIME_COLUMN,
  94             TRACE_COLUMN
  95     };
  96
  97     // ------------------------------------------------------------------------
  98     // Fields
  99     // ------------------------------------------------------------------------
 100
 101     // The timegraph combo
 102     private TimeGraphCombo fTimeGraphCombo;
 103
 104     // The selected experiment
 105     private TmfExperiment<ITmfEvent> fSelectedExperiment;
 106
 107     // The timegraph entry list
 108     private ArrayList<ControlFlowEntry> fEntryList;
 109
 110     // The start time
 111     private long fStartTime;
 112
 113     // The end time
 114     private long fEndTime;
 115
 116     // The display width
 117     private int fDisplayWidth;
 118
 119     // The zoom thread
 120     private ZoomThread fZoomThread;
 121
 122     // The next resource action
 123     private Action fNextResourceAction;
 124
 125     // The previous resource action
 126     private Action fPreviousResourceAction;
 127
 128     // ------------------------------------------------------------------------
 129     // Classes
 130     // ------------------------------------------------------------------------
 131
 132     private class TreeContentProvider implements ITreeContentProvider {
 133
 134         @Override
 135         public void dispose() {
 136         }
 137
 138         @Override
 139         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 140         }
 141
 142         @Override
 143         public Object[] getElements(Object inputElement) {
 144             return (ITimeGraphEntry[]) inputElement;
 145         }
 146
 147         @Override
 148         public Object[] getChildren(Object parentElement) {
 149             ITimeGraphEntry entry = (ITimeGraphEntry) parentElement;
 150             return entry.getChildren();
 151         }
 152
 153         @Override
 154         public Object getParent(Object element) {
 155             ITimeGraphEntry entry = (ITimeGraphEntry) element;
 156             return entry.getParent();
 157         }
 158
 159         @Override
 160         public boolean hasChildren(Object element) {
 161             ITimeGraphEntry entry = (ITimeGraphEntry) element;
 162             return entry.hasChildren();
 163         }
 164
 165     }
 166
 167     private class TreeLabelProvider implements ITableLabelProvider {
 168
 169         @Override
 170         public void addListener(ILabelProviderListener listener) {
 171         }
 172
 173         @Override
 174         public void dispose() {
 175         }
 176
 177         @Override
 178         public boolean isLabelProperty(Object element, String property) {
 179             return false;
 180         }
 181
 182         @Override
 183         public void removeListener(ILabelProviderListener listener) {
 184         }
 185
 186         @Override
 187         public Image getColumnImage(Object element, int columnIndex) {
 188             return null;
 189         }
 190
 191         @Override
 192         public String getColumnText(Object element, int columnIndex) {
 193             ControlFlowEntry entry = (ControlFlowEntry) element;
 194             if (columnIndex == 0) {
 195                 return entry.getName();
 196             } else if (columnIndex == 1) {
 197                 return Integer.toString(entry.getThreadId());
 198             } else if (columnIndex == 2) {
 199                 if (entry.getParentThreadId() > 0) {
 200                     return Integer.toString(entry.getParentThreadId());
 201                 }
 202             } else if (columnIndex == 3) {
 203                 return Utils.formatTime(entry.getBirthTime(), TimeFormat.ABSOLUTE, Resolution.NANOSEC);
 204             } else if (columnIndex == 4) {
 205                 return entry.getTrace().getName();
 206             }
 207             return ""; //$NON-NLS-1$
 208         }
 209
 210     }
 211
 212     private class ZoomThread extends Thread {
 213         private long fZoomStartTime;
 214         private long fZoomEndTime;
 215         private long fResolution;
 216         private IProgressMonitor fMonitor;
 217
 218         public ZoomThread(long startTime, long endTime) {
 219             super("ControlFlowView zoom"); //$NON-NLS-1$
 220             fZoomStartTime = startTime;
 221             fZoomEndTime = endTime;
 222             fResolution = Math.max(1, (fZoomEndTime - fZoomStartTime) / fDisplayWidth);
 223             fMonitor = new NullProgressMonitor();
 224         }
 225
 226         @Override
 227         public void run() {
 228             ArrayList<ControlFlowEntry> entryList = fEntryList;
 229             if (entryList == null) {
 230                 return;
 231             }
 232             for (ControlFlowEntry entry : entryList) {
 233                 if (fMonitor.isCanceled()) {
 234                     return;
 235                 }
 236                 zoom(entry, fMonitor);
 237             }
 238             redraw();
 239         }
 240
 241         private void zoom(ControlFlowEntry entry, IProgressMonitor monitor) {
 242             List<ITimeEvent> zoomedEventList = getEventList(entry, fZoomStartTime, fZoomEndTime, fResolution, monitor);
 243             if (fMonitor.isCanceled()) {
 244                 return;
 245             }
 246             entry.setZoomedEventList(zoomedEventList);
 247             for (ControlFlowEntry child : entry.getChildren()) {
 248                 if (fMonitor.isCanceled()) {
 249                     return;
 250                 }
 251                 zoom(child, monitor);
 252             }
 253         }
 254
 255         public void cancel() {
 256             fMonitor.setCanceled(true);
 257         }
 258     }
 259
 260     // ------------------------------------------------------------------------
 261     // Constructors
 262     // ------------------------------------------------------------------------
 263
 264     public ControlFlowView() {
 265         super(ID);
 266         fDisplayWidth = Display.getDefault().getBounds().width;
 267     }
 268
 269     // ------------------------------------------------------------------------
 270     // ViewPart
 271     // ------------------------------------------------------------------------
 272
 273     /* (non-Javadoc)
 274      * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)
 275      */
 276     @Override
 277     public void createPartControl(Composite parent) {
 278         fTimeGraphCombo = new TimeGraphCombo(parent, SWT.NONE);
 279
 280         fTimeGraphCombo.setTreeContentProvider(new TreeContentProvider());
 281
 282         fTimeGraphCombo.setTreeLabelProvider(new TreeLabelProvider());
 283
 284         fTimeGraphCombo.setTimeGraphProvider(new ControlFlowPresentationProvider());
 285
 286         fTimeGraphCombo.setTreeColumns(COLUMN_NAMES);
 287
 288         fTimeGraphCombo.getTimeGraphViewer().addRangeListener(new ITimeGraphRangeListener() {
 289             @Override
 290             public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 291                 final long startTime = event.getStartTime();
 292                 final long endTime = event.getEndTime();
 293                 TmfTimeRange range = new TmfTimeRange(new CtfTmfTimestamp(startTime), new CtfTmfTimestamp(endTime));
 294                 TmfTimestamp time = new CtfTmfTimestamp(fTimeGraphCombo.getTimeGraphViewer().getSelectedTime());
 295                 broadcast(new TmfRangeSynchSignal(ControlFlowView.this, range, time));
 296                 if (fZoomThread != null) {
 297                     fZoomThread.cancel();
 298                 }
 299                 startZoomThread(startTime, endTime);
 300             }
 301         });
 302
 303         fTimeGraphCombo.getTimeGraphViewer().addTimeListener(new ITimeGraphTimeListener() {
 304             @Override
 305             public void timeSelected(TimeGraphTimeEvent event) {
 306                 long time = event.getTime();
 307                 broadcast(new TmfTimeSynchSignal(ControlFlowView.this, new CtfTmfTimestamp(time)));
 308             }
 309         });
 310
 311         fTimeGraphCombo.addSelectionListener(new ITimeGraphSelectionListener() {
 312             @Override
 313             public void selectionChanged(TimeGraphSelectionEvent event) {
 314                 //ITimeGraphEntry selection = event.getSelection();
 315             }
 316         });
 317
 318         fTimeGraphCombo.getTimeGraphViewer().setTimeCalendarFormat(true);
 319
 320         final Thread thread = new Thread("ControlFlowView build") { //$NON-NLS-1$
 321             @Override
 322             public void run() {
 323                 if (TmfExperiment.getCurrentExperiment() != null) {
 324                     selectExperiment(TmfExperiment.getCurrentExperiment());
 325                 }
 326             }
 327         };
 328         thread.start();
 329
 330         // View Action Handling
 331         makeActions();
 332         contributeToActionBars();
 333     }
 334
 335     /* (non-Javadoc)
 336      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 337      */
 338     @Override
 339     public void setFocus() {
 340         fTimeGraphCombo.setFocus();
 341     }
 342
 343     // ------------------------------------------------------------------------
 344     // Signal handlers
 345     // ------------------------------------------------------------------------
 346
 347     @TmfSignalHandler
 348     public void experimentSelected(final TmfExperimentSelectedSignal<? extends ITmfEvent> signal) {
 349         if (signal.getExperiment().equals(fSelectedExperiment)) {
 350             return;
 351         }
 352
 353         final Thread thread = new Thread("ControlFlowView build") { //$NON-NLS-1$
 354             @Override
 355             public void run() {
 356                 selectExperiment(signal.getExperiment());
 357             }
 358         };
 359         thread.start();
 360     }
 361
 362     @TmfSignalHandler
 363     public void synchToTime(final TmfTimeSynchSignal signal) {
 364         if (signal.getSource() == this) {
 365             return;
 366         }
 367         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 368
 369         int thread = -1;
 370         for (ITmfTrace<?> trace : fSelectedExperiment.getTraces()) {
 371             if (thread > 0) {
 372                 break;
 373             }
 374             if (trace instanceof CtfKernelTrace) {
 375                 CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) trace;
 376                 IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 377                 if (time >= ssq.getStartTime() && time <= ssq.getCurrentEndTime()) {
 378                     List<Integer> currentThreadQuarks = ssq.getQuarks(Attributes.CPUS, "*", Attributes.CURRENT_THREAD);  //$NON-NLS-1$
 379                     for (int currentThreadQuark : currentThreadQuarks) {
 380                         try {
 381                             ITmfStateInterval currentThreadInterval = ssq.querySingleState(time, currentThreadQuark);
 382                             int currentThread = currentThreadInterval.getStateValue().unboxInt();
 383                             if (currentThread > 0) {
 384                                 int statusQuark = ssq.getQuarkAbsolute(Attributes.THREADS, Integer.toString(currentThread), Attributes.STATUS);
 385                                 ITmfStateInterval statusInterval = ssq.querySingleState(time, statusQuark);
 386                                 if (statusInterval.getStartTime() == time) {
 387                                     thread = currentThread;
 388                                     break;
 389                                 }
 390                             }
 391                         } catch (AttributeNotFoundException e) {
 392                             e.printStackTrace();
 393                         } catch (TimeRangeException e) {
 394                             e.printStackTrace();
 395                         } catch (StateValueTypeException e) {
 396                             e.printStackTrace();
 397                         }
 398                     }
 399                 }
 400             }
 401         }
 402         final int selectedThread = thread;
 403
 404         Display.getDefault().asyncExec(new Runnable() {
 405             @Override
 406             public void run() {
 407                 if (fTimeGraphCombo.isDisposed()) {
 408                     return;
 409                 }
 410                 fTimeGraphCombo.getTimeGraphViewer().setSelectedTime(time, true);
 411                 startZoomThread(fTimeGraphCombo.getTimeGraphViewer().getTime0(), fTimeGraphCombo.getTimeGraphViewer().getTime1());
 412
 413                 if (selectedThread > 0) {
 414                     for (Object element : fTimeGraphCombo.getTimeGraphViewer().getExpandedElements()) {
 415                         if (element instanceof ControlFlowEntry) {
 416                             ControlFlowEntry entry = (ControlFlowEntry) element;
 417                             if (entry.getThreadId() == selectedThread) {
 418                                 fTimeGraphCombo.setSelection(entry);
 419                             }
 420                         }
 421                     }
 422                 }
 423             }
 424         });
 425     }
 426
 427     @TmfSignalHandler
 428     public void synchToRange(final TmfRangeSynchSignal signal) {
 429         if (signal.getSource() == this) {
 430             return;
 431         }
 432         final long startTime = signal.getCurrentRange().getStartTime().normalize(0, -9).getValue();
 433         final long endTime = signal.getCurrentRange().getEndTime().normalize(0, -9).getValue();
 434         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 435         Display.getDefault().asyncExec(new Runnable() {
 436             @Override
 437             public void run() {
 438                 if (fTimeGraphCombo.isDisposed()) {
 439                     return;
 440                 }
 441                 fTimeGraphCombo.getTimeGraphViewer().setStartFinishTime(startTime, endTime);
 442                 fTimeGraphCombo.getTimeGraphViewer().setSelectedTime(time, false);
 443                 startZoomThread(startTime, endTime);
 444             }
 445         });
 446     }
 447
 448     // ------------------------------------------------------------------------
 449     // Internal
 450     // ------------------------------------------------------------------------
 451
 452     @SuppressWarnings("unchecked")
 453     private void selectExperiment(TmfExperiment<?> experiment) {
 454         fStartTime = Long.MAX_VALUE;
 455         fEndTime = Long.MIN_VALUE;
 456         fSelectedExperiment = (TmfExperiment<ITmfEvent>) experiment;
 457         ArrayList<ControlFlowEntry> entryList = new ArrayList<ControlFlowEntry>();
 458         for (ITmfTrace<?> trace : experiment.getTraces()) {
 459             if (trace instanceof CtfKernelTrace) {
 460                 CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) trace;
 461                 IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 462                 long start = ssq.getStartTime();
 463                 long end = ssq.getCurrentEndTime();
 464                 fStartTime = Math.min(fStartTime, start);
 465                 fEndTime = Math.max(fEndTime, end);
 466                 List<Integer> threadQuarks = ssq.getQuarks(Attributes.THREADS, "*"); //$NON-NLS-1$
 467                 for (int threadQuark : threadQuarks) {
 468                     String threadName = ssq.getAttributeName(threadQuark);
 469                     int threadId = -1;
 470                     try {
 471                         threadId = Integer.parseInt(threadName);
 472                     } catch (NumberFormatException e1) {
 473                         continue;
 474                     }
 475                     if (threadId == 0) { // ignore the swapper thread
 476                         continue;
 477                     }
 478                     int execNameQuark = -1;
 479                     try {
 480                         try {
 481                             execNameQuark = ssq.getQuarkRelative(threadQuark, Attributes.EXEC_NAME);
 482                         } catch (AttributeNotFoundException e) {
 483                             continue;
 484                         }
 485                         int ppidQuark = ssq.getQuarkRelative(threadQuark, Attributes.PPID);
 486                         List<ITmfStateInterval> execNameIntervals = ssq.queryHistoryRange(execNameQuark, start, end);
 487                         long birthTime = -1;
 488                         for (ITmfStateInterval execNameInterval : execNameIntervals) {
 489                             if (!execNameInterval.getStateValue().isNull() && execNameInterval.getStateValue().getType() == 1) {
 490                                 String execName = execNameInterval.getStateValue().unboxStr();
 491                                 long startTime = execNameInterval.getStartTime();
 492                                 long endTime = execNameInterval.getEndTime() + 1;
 493                                 if (birthTime == -1) {
 494                                     birthTime = startTime;
 495                                 }
 496                                 int ppid = -1;
 497                                 if (ppidQuark != -1) {
 498                                     ITmfStateInterval ppidInterval = ssq.querySingleState(startTime, ppidQuark);
 499                                     ppid = ppidInterval.getStateValue().unboxInt();
 500                                 }
 501                                 ControlFlowEntry entry = new ControlFlowEntry(threadQuark, ctfKernelTrace, execName, threadId, ppid, birthTime, startTime, endTime);
 502                                 entryList.add(entry);
 503                                 entry.addEvent(new TimeEvent(entry, startTime, endTime - startTime));
 504                             } else {
 505                                 birthTime = -1;
 506                             }
 507                         }
 508                     } catch (AttributeNotFoundException e) {
 509                         e.printStackTrace();
 510                     } catch (TimeRangeException e) {
 511                         e.printStackTrace();
 512                     } catch (StateValueTypeException e) {
 513                         e.printStackTrace();
 514                     }
 515                 }
 516             }
 517             buildTree(entryList);
 518             refresh(INITIAL_WINDOW_OFFSET);
 519             ControlFlowEntry[] entries = fEntryList.toArray(new ControlFlowEntry[0]);
 520             Arrays.sort(entries);
 521             for (ControlFlowEntry entry : entries) {
 522                 buildStatusEvents(entry);
 523             }
 524         }
 525     }
 526
 527     private void buildTree(ArrayList<ControlFlowEntry> entryList) {
 528         ArrayList<ControlFlowEntry> rootList = new ArrayList<ControlFlowEntry>();
 529         for (ControlFlowEntry entry : entryList) {
 530             boolean root = true;
 531             if (entry.getParentThreadId() > 0) {
 532                 for (ControlFlowEntry parent : entryList) {
 533                     if (parent.getThreadId() == entry.getParentThreadId() &&
 534                             entry.getStartTime() >= parent.getStartTime() &&
 535                             entry.getStartTime() <= parent.getEndTime()) {
 536                         parent.addChild(entry);
 537                         root = false;
 538                         break;
 539                     }
 540                 }
 541             }
 542             if (root) {
 543                 rootList.add(entry);
 544             }
 545         }
 546         fEntryList = rootList;
 547     }
 548
 549     private void buildStatusEvents(ControlFlowEntry entry) {
 550         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 551         long start = ssq.getStartTime();
 552         long end = ssq.getCurrentEndTime();
 553         long resolution = Math.max(1, (end - start) / fDisplayWidth);
 554         List<ITimeEvent> eventList = getEventList(entry, entry.getStartTime(), entry.getEndTime(), resolution, new NullProgressMonitor());
 555         entry.setEventList(eventList);
 556         redraw();
 557         for (ITimeGraphEntry child : entry.getChildren()) {
 558             buildStatusEvents((ControlFlowEntry) child);
 559         }
 560     }
 561
 562     private List<ITimeEvent> getEventList(ControlFlowEntry entry, long startTime, long endTime, long resolution, IProgressMonitor monitor) {
 563         startTime = Math.max(startTime, entry.getStartTime());
 564         endTime = Math.min(endTime, entry.getEndTime());
 565         if (endTime <= startTime) {
 566             return null;
 567         }
 568         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 569         List<ITimeEvent> eventList = null;
 570         try {
 571             int statusQuark = ssq.getQuarkRelative(entry.getThreadQuark(), Attributes.STATUS);
 572             List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, startTime, endTime - 1, resolution);
 573             eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
 574             long lastEndTime = -1;
 575             for (ITmfStateInterval statusInterval : statusIntervals) {
 576                 if (monitor.isCanceled()) {
 577                     return null;
 578                 }
 579                 long time = statusInterval.getStartTime();
 580                 long duration = statusInterval.getEndTime() - time + 1;
 581                 int status = -1;
 582                 try {
 583                     status = statusInterval.getStateValue().unboxInt();
 584                 } catch (StateValueTypeException e) {
 585                     e.printStackTrace();
 586                 }
 587                 if (lastEndTime != time && lastEndTime != -1) {
 588                     eventList.add(new ControlFlowEvent(entry, lastEndTime, time - lastEndTime, 0));
 589                 }
 590                 eventList.add(new ControlFlowEvent(entry, time, duration, status));
 591                 lastEndTime = time + duration;
 592             }
 593         } catch (AttributeNotFoundException e) {
 594             e.printStackTrace();
 595         } catch (TimeRangeException e) {
 596             e.printStackTrace();
 597         }
 598         return eventList;
 599     }
 600
 601     private void refresh(final long windowRange) {
 602         Display.getDefault().asyncExec(new Runnable() {
 603             @Override
 604             public void run() {
 605                 if (fTimeGraphCombo.isDisposed()) {
 606                     return;
 607                 }
 608                 ITimeGraphEntry[] entries = fEntryList.toArray(new ITimeGraphEntry[0]);
 609                 Arrays.sort(entries);
 610                 fTimeGraphCombo.setInput(entries);
 611                 fTimeGraphCombo.getTimeGraphViewer().setTimeBounds(fStartTime, fEndTime);
 612
 613                 long endTime = fStartTime + windowRange;
 614
 615                 if (fEndTime < endTime) {
 616                     endTime = fEndTime;
 617                 }
 618                 fTimeGraphCombo.getTimeGraphViewer().setStartFinishTime(fStartTime, endTime);
 619                 for (TreeColumn column : fTimeGraphCombo.getTreeViewer().getTree().getColumns()) {
 620                     column.pack();
 621                 }
 622
 623                 startZoomThread(fStartTime, endTime);
 624             }
 625         });
 626     }
 627
 628     private void redraw() {
 629         Display.getDefault().asyncExec(new Runnable() {
 630             @Override
 631             public void run() {
 632                 if (fTimeGraphCombo.isDisposed()) {
 633                     return;
 634                 }
 635                 fTimeGraphCombo.redraw();
 636                 fTimeGraphCombo.update();
 637             }
 638         });
 639     }
 640
 641     private void startZoomThread(long startTime, long endTime) {
 642         if (fZoomThread != null) {
 643             fZoomThread.cancel();
 644         }
 645         fZoomThread = new ZoomThread(startTime, endTime);
 646         fZoomThread.start();
 647     }
 648
 649     private void makeActions() {
 650         fPreviousResourceAction = fTimeGraphCombo.getTimeGraphViewer().getPreviousItemAction();
 651         fPreviousResourceAction.setText(Messages.ControlFlowView_previousProcessActionNameText);
 652         fPreviousResourceAction.setToolTipText(Messages.ControlFlowView_previousProcessActionToolTipText);
 653         fNextResourceAction = fTimeGraphCombo.getTimeGraphViewer().getNextItemAction();
 654         fNextResourceAction.setText(Messages.ControlFlowView_nextProcessActionNameText);
 655         fNextResourceAction.setToolTipText(Messages.ControlFlowView_nextProcessActionToolTipText);
 656     }
 657
 658     private void contributeToActionBars() {
 659         IActionBars bars = getViewSite().getActionBars();
 660         fillLocalToolBar(bars.getToolBarManager());
 661     }
 662
 663     private void fillLocalToolBar(IToolBarManager manager) {
 664         manager.add(fTimeGraphCombo.getTimeGraphViewer().getShowLegendAction());
 665         manager.add(new Separator());
 666         manager.add(fTimeGraphCombo.getTimeGraphViewer().getResetScaleAction());
 667         manager.add(fTimeGraphCombo.getTimeGraphViewer().getPreviousEventAction());
 668         manager.add(fTimeGraphCombo.getTimeGraphViewer().getNextEventAction());
 669         manager.add(fPreviousResourceAction);
 670         manager.add(fNextResourceAction);
 671         manager.add(fTimeGraphCombo.getTimeGraphViewer().getZoomInAction());
 672         manager.add(fTimeGraphCombo.getTimeGraphViewer().getZoomOutAction());
 673         manager.add(new Separator());
 674     }
 675 }