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