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