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