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